diff --git a/.dockerignore b/.dockerignore index bc16e55..796b65c 100644 --- a/.dockerignore +++ b/.dockerignore @@ -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 diff --git a/.env.example b/.env.example index 2b32655..62fa5c8 100644 --- a/.env.example +++ b/.env.example @@ -28,3 +28,94 @@ OTEL_SERVICE_NAME=messenger-api OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318 OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=lab + + +# --- Дополнительные настройки этого решения (значения по умолчанию из 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 + +# --- с lab6: наблюдаемость (OpenTelemetry SDK в API и worker -> otel-collector) --- +# OTEL_SERVICE_NAME выше — для API; у worker в compose.yaml свой: messenger-worker. +# service.version = APP_VERSION, service.instance.id = hostname контейнера (как X-Instance-Id). +# Новые имена HTTP-метрик/атрибутов semantic conventions (http.server.request.duration в секундах). +OTEL_SEMCONV_STABILITY_OPT_IN=http +# Контекст трассы — только W3C traceparent/tracestate (без baggage: его нет в jobs.schema.json). +OTEL_PROPAGATORS=tracecontext +# Метрики отправляются раз в 10 с (миллисекунды). +OTEL_METRIC_EXPORT_INTERVAL=10000 +# Одна отправка любого сигнала — не дольше 5 с. ВНИМАНИЕ: Python SDK 1.45 читает это значение +# в СЕКУНДАХ (в спецификации — миллисекунды): 10000 здесь означало бы ~3 часа ожидания. +OTEL_EXPORTER_OTLP_TIMEOUT=5 +# OTEL_SDK_DISABLED=true — выключить телеметрию (останутся только JSON-логи в stdout). diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..1f1067c --- /dev/null +++ b/.gitattributes @@ -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 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..5057f82 --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/Makefile b/Makefile index 5d86d17..596c93d 100644 --- a/Makefile +++ b/Makefile @@ -1,13 +1,34 @@ 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 \ + telemetry-check dashboard-check incident-worker incident-db incident-db-down telemetry-outage \ + telemetry-persistence alerts telemetry-logs 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)" + @echo "telemetry-check, dashboard-check, incident-worker, incident-db, incident-db-down, telemetry-outage, telemetry-persistence, alerts, telemetry-logs: observability (lab6)" check: $(PYTHON) scripts/check_contract.py @@ -28,3 +49,235 @@ 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 otel-collector + +# Вернуть остановленные реплики (после 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="; exit 2) + docker compose exec -T api python -m messenger.jobs show $(ID) + +replay: + @test -n "$(ID)" || (echo "make replay 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 + +# ---------- lab6: наблюдаемость (Grafana http://127.0.0.1:3000, Prometheus http://127.0.0.1:9090) ---------- +# Уровни 3–4: X-Request-Id -> лог в Loki -> trace в Tempo; upload -> publish -> consume -> retry -> S3/DB +# в одной трассе; метрики без ID в labels; нет паролей, токенов и текстов сообщений в телеметрии. +telemetry-check: + $(PYTHON) student-tests/check_telemetry.py +# Источники данных и dashboard импортированы из Git, каждый запрос панели работает, alert rules загружены. +dashboard-check: + $(PYTHON) student-tests/check_dashboard.py +# Уровень 4, инцидент 1: worker остановлен -> QueueLagHigh firing -> worker запущен -> resolved (~5 мин). +incident-worker: + $(PYTHON) student-tests/incident_worker.py +# Уровень 4, инцидент 2: медленный handler против медленной БД (LOCK TABLE) -> HighErrorRate firing/resolved (~6 мин). +incident-db: + $(PYTHON) student-tests/incident_db.py +# То же для недоступной БД (docker compose pause postgres): 5xx только на входе HAProxy (~5 мин). +incident-db-down: + $(PYTHON) student-tests/incident_db.py --down +# Уровень 4, сценарий 3: остановка Tempo и Loki (3 мин) и Collector (1 мин) под нагрузкой (~7 мин). +telemetry-outage: + $(PYTHON) student-tests/telemetry_outage.py +# История телеметрии в volumes: перезапуск Prometheus, Loki, Tempo, Grafana — старые данные на месте. +telemetry-persistence: + $(PYTHON) student-tests/telemetry_persistence.py +# Состояние alert rules (inactive / pending / firing) из Prometheus. +alerts: + $(PYTHON) student-tests/obs.py alerts +# Последние предупреждения и ошибки API и worker из Loki. +telemetry-logs: + $(PYTHON) student-tests/obs.py logs diff --git a/REPORT.md b/REPORT.md index b97ae42..e89f60b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,188 @@ # Отчёт — лабораторная 6 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Гаджиев Нухбала, БВТ2303 +- Целевая оценка; выбранный трек 5, если нужен: 4, трек 5 не выбран - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: всё из lab5 и новое: OpenTelemetry Python SDK 1.45.2 и автоинструментация 0.66b2 (FastAPI, psycopg, botocore, system-metrics, logging), OpenTelemetry Collector contrib 0.140.1, Prometheus 3.7.3, Loki 3.5.8, Tempo 2.9.0, Grafana 12.2.1. Документация: OTel Collector configuration (memory_limiter, batch, sending_queue, retry_on_failure), OTel context propagation и W3C Trace Context, semantic conventions (HTTP, messaging, db.client.connection), Prometheus (OTLP receiver, histograms and summaries, alerting rules), Loki (OTLP ingestion, structured metadata), Tempo (TraceQL), Grafana provisioning. ИИ использовался только как вспомогательный ресурс: для оценки решения, написания комментариев к коду и составления текстовых документов. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Проверял на Windows 11 в Git Bash с Docker Desktop (WSL 2). Нужны Docker с Compose, Python 3 (только для тестов, стандартная библиотека) и GNU Make. Образы закреплены: всё из lab5 (python:3.12.8-slim-bookworm, haproxy:3.2.25-alpine, postgres:17.10-bookworm, valkey/valkey:8.1.9, chrislusf/seaweedfs:4.44, rabbitmq:4.2.9-alpine) и otel/opentelemetry-collector-contrib:0.140.1, prom/prometheus:v3.7.3, grafana/loki:3.5.8, grafana/tempo:2.9.0, grafana/grafana:12.2.1. Перед запуском остановить стенд lab5 (`docker compose -p mtusi-lab5 down`): заняты те же порты. + +```sh +git clone https://gitea.privcloud.tech/ng14/mtusi2026lab6.git && cd mtusi2026lab6 +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, пароль Grafana +docker compose up -d --build --wait # + otel-collector, prometheus, loki, tempo, grafana +make ps + +make check PYTHON=python +make test PYTHON=python +make telemetry-check PYTHON=python # запрос -> лог -> trace, upload -> worker в одной трассе +make dashboard-check PYTHON=python # provisioning и запросы всех панелей +``` + +Grafana: http://127.0.0.1:3000, пользователь `admin`, пароль — `secrets/grafana_admin_password`. Dashboard «Messenger lab6: API, worker, очередь, SLO» (папка Messenger) и три источника данных импортируются при старте из `infra/grafana`, вручную ничего не создаётся. Alerts: http://127.0.0.1:9090/alerts или `make alerts`. + +Сценарии уровня 4: `make incident-worker`, `make incident-db`, `make incident-db-down`, `make telemetry-outage`, `make telemetry-persistence`. Проверки прошлых лаб остались (`make student-test`, `db-test`, `test-failover`, `test-persistence`, `check-stack` и др.). + +Безопасная остановка: `make down` (volumes остаются, в том числе `promdata`, `lokidata`, `tempodata`, `grafanadata`). Намеренное удаление учебных данных: `docker compose down -v`, затем `rm -rf secrets` и снова `sh scripts/init-secrets.sh`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab5, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```text +клиент -> lb (HAProxy, 127.0.0.1:8080) -> api x2 -> postgres / valkey / s3 / broker -> worker (как в lab5) + +api x2, worker --OTLP/HTTP :4318--> otel-collector --> prometheus (метрики, alert rules) 127.0.0.1:9090 + (SDK: трассы, метрики, логи) memory_limiter --> loki (логи) + batch, очереди --> tempo (трассы) +prometheus <-- scrape: otel-collector:8888 (метрики самого Collector), lb:8404/metrics (ответы клиентам) +grafana (127.0.0.1:3000) --> prometheus, loki, tempo сети: telemetry (internal), ops (только порты) +``` + +| Роль | Сервис | Зачем | +| --- | --- | --- | +| Сборщик | `otel-collector` | принимает OTLP от API и worker, ограничивает память и буферы, удаляет чувствительные атрибуты, отправляет в хранилища. Сам ничего не хранит | +| Метрики | `prometheus` (volume `promdata`, 15 дней) | числа во времени: RPS, ошибки, гистограммы задержек, очередь, пул. Считает alert rules | +| Логи | `loki` (volume `lokidata`, 7 дней) | структурные записи событий: что случилось, с каким trace_id, request_id | +| Трассы | `tempo` (volume `tempodata`, 7 дней) | путь одного запроса или задания через процессы: какой шаг сколько длился и где ошибка | +| Интерфейс | `grafana` (volume `grafanadata`) | dashboard и поиск по трём хранилищам. Сама сигналы не хранит | + +Что перенесено из lab5: весь код, миграции 001–006, свои тесты, Dockerfile, конфиги, скрипты. Бизнес-API не менялся. + +Что добавлено: +- `src/messenger/telemetry.py`: SDK трассы, метрики и логи по OTLP; ресурс `service.name` (`messenger-api` / `messenger-worker`), `service.version`, `service.instance.id` (hostname контейнера), `deployment.environment.name=lab`; JSON-логи в stdout и OTLP с `event`, `trace_id`, `span_id`; автоинструментация FastAPI, psycopg, botocore, CPU/RAM процесса. +- Связь через очередь: в строку outbox пишется W3C `traceparent` span загрузки (`jobs.enqueue`). Relay создаёт PRODUCER span «send attachments» дочерним к нему и кладёт в сообщение уже свой `traceparent`. Worker создаёт CONSUMER span «process attachments.process» дочерним к PRODUCER. Повтор пишет в outbox `traceparent` span обработки, поэтому следующая попытка — в той же трассе. Без активного span (истёк lease, replay) копируется `traceparent` прошлой строки. +- Выборка трасс: все трассы с родителем сохраняются целиком. Отбрасываются только CLIENT-спаны без родителя: опрос outbox раз в секунду, продление lease, проверка S3 для readiness. Иначе это была бы трасса в секунду из одного SQL. +- `src/messenger/queuestats.py`: глубина очереди и возраст старейшего задания из PostgreSQL. Считаются в API, а не в worker, чтобы при остановленном worker график рос, а не пропадал. +- `infra/otel/collector.yaml`, `infra/prometheus/` (конфиг, `rules/alerts.yml`, `runbooks.md`), `infra/loki/loki.yaml`, `infra/tempo/tempo.yaml`, `infra/grafana/` (provisioning и `dashboards/messenger.json`). HAProxy отдаёт метрики на `:8404/metrics`. +- Точка отказа `api_slow_handler` (медленный обработчик для инцидента 2) и свои проверки lab6 в `student-tests/`. + +Новые переменные (`.env.example`): + +| Переменная | Значение | +| --- | --- | +| OTEL_SERVICE_NAME | `messenger-api` (у worker в compose — `messenger-worker`) | +| OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_PROTOCOL | `http://otel-collector:4318`, `http/protobuf` | +| OTEL_RESOURCE_ATTRIBUTES | `deployment.environment.name=lab` | +| OTEL_SEMCONV_STABILITY_OPT_IN | `http`: новые имена HTTP-метрик (`http.server.request.duration` в секундах) | +| OTEL_PROPAGATORS | `tracecontext`: только traceparent/tracestate, без baggage (его нет в jobs.schema.json) | +| OTEL_METRIC_EXPORT_INTERVAL | 10000 мс | +| OTEL_EXPORTER_OTLP_TIMEOUT | 5. Python SDK читает это значение в секундах, а не в миллисекундах, как в спецификации | + +### Сигналы: логическое имя → реальное имя + +| Сигнал (contracts/observability.md) | Имя в SDK → в Prometheus | Единица | Labels | +| --- | --- | --- | --- | +| HTTP requests | `http.server.request.duration` (count) → `http_server_request_duration_seconds_count` | запросы | `http_request_method`, `http_route` (шаблон), `http_response_status_code`; класс кода — `=~"5.."` в запросе | +| HTTP duration | та же гистограмма → `..._bucket`, `..._sum` | секунды | то же + `le`; buckets 5 мс … 10 с | +| Jobs processed / failed | `messenger.jobs.processed` → `messenger_jobs_processed_total` | доставки | `messenger_job_type`, `outcome` (ready, retry, failed, skipped, lost, db_unavailable, invalid) | +| Job processing duration | `messenger.job.duration` → `messenger_job_duration_seconds_*` | секунды | `messenger_job_type`, `outcome`; buckets 0.1 … 120 с | +| Queue depth / oldest age | `messenger.queue.depth`, `messenger.queue.oldest_age` → `messenger_queue_depth`, `messenger_queue_oldest_age_seconds` | задания / секунды | `queue`, `state` (ready, delayed, processing) | +| Outbox | `messenger.outbox.pending`, `.oldest_age`, `.published` | сообщения / секунды | `queue` | +| DB pool | `db.client.connection.count`, `.max`, `.pending_requests` → `db_client_connection_*` | соединения | `db_client_connection_pool_name`, `db_client_connection_state` (used, idle) | +| Worker saturation | `messenger.worker.busy`, `messenger.worker.capacity` | задания | — | +| CPU / RAM процесса | `process.cpu.time`, `process.memory.usage` → `process_cpu_time_seconds_total`, `process_memory_usage_bytes` | секунды CPU / байты | `type` (user, system) | +| End-to-end time to ready | `messenger.attachment.time_to_ready` → `messenger_attachment_time_to_ready_seconds_*` | секунды | `messenger_job_type`; buckets 0.5 … 1800 с | +| Ответы клиентам на входе | HAProxy `haproxy_frontend_http_responses_total` | ответы | `proxy`, `code` (2xx, 4xx, 5xx…) | +| Логи API и worker | Loki: labels `service_name`, `service_instance_id`, `deployment_environment_name`; structured metadata `event`, `severity_text`, `trace_id`, `span_id`, `request_id` | — | — | +| Трассы | SERVER (HTTP), PRODUCER (relay), CONSUMER (worker), INTERNAL (jobs.claim, image.process, jobs.complete/retry/fail), CLIENT (SQL, S3) | мс | статус ERROR при 5xx, retry, failed | + +Ресурс: `service.name` → label `job` в Prometheus и `service_name` в Loki; `service.instance.id` → `instance` и `service_instance_id`. + +Не labels метрик: user_id, chat_id, message_id, attachment_id, request_id, raw URL, filename, текст. Маршрут — шаблон `/api/v1/chats/{chat_id}/messages`. `make telemetry-check` проверяет имена labels всех серий приложения. В логах и трассах есть только технические ID синтетических данных (`request_id`, `attachment_id`, `job_id`): по `attachment_id` находится трасса загрузки, по `request_id` (заголовок `X-Request-Id`) — лог и trace HTTP-ошибки. Пароли, Authorization, токены, тексты сообщений, картинки и query-строки в телеметрию не попадают. В логе запроса только маршрут-шаблон, а не путь. Collector дополнительно удаляет `url.query`, `url.full`, `http.target` и заголовки авторизации. + +### SLI, SLO и alerts + +Окно SLO — скользящий 1 час (учебный стенд). Recording rules в `infra/prometheus/rules/alerts.yml`. + +| SLO | SLI (запрос) | Цель | +| --- | --- | --- | +| SLO-1 доступность | `messenger:edge_availability:ratio1h` = 1 − 5xx / все ответы фронтенда `api_in` HAProxy за 1 ч | ≥ 99% | +| SLO-2 задержка | `messenger:http_latency_p95:5m` = `histogram_quantile(0.95, sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api"}[5m])))` | < 0.5 с | +| SLO-3 обработка | `messenger:time_to_ready_under_30s:ratio1h` = bucket `le=30` / count за 1 ч | ≥ 95% | + +Доля ошибок. Числитель — ответы 5xx клиентам на входе HAProxy, знаменатель — все ответы входа. Так считаются и 503, которые HAProxy отдаёт сам, когда нет готовой реплики (БД недоступна). 4xx (неверный пароль, чужой чат) — ошибка клиента, а не отказ сервиса. Проверки `/health` от HAProxy — не запросы фронтенда. Для поиска причины на dashboard есть и доля 5xx приложения (без `/health`). + +Перцентили считаются только из buckets гистограммы, сложенных по всем репликам (`sum by (le)`). Не из средних и не как среднее p95 реплик. + +| Alert | Условие | Окно / for | Зачем | +| --- | --- | --- | --- | +| HighErrorRate | `messenger:edge_error_ratio:rate2m > 0.05` и трафик > 0.2 запроса/с | 2 мин / 1 мин | SLO-1: клиенты получают 5xx | +| QueueLagHigh | `max by (queue) (messenger_queue_oldest_age_seconds) > 60` | — / 1 мин | задание ждёт worker дольше минуты | +| TelemetryExportFailing | ошибки отправки exporter Collector или очередь > 20 пачек | 2 мин / 1 мин | хранилище телеметрии недоступно | + +Runbook для каждого — `infra/prometheus/runbooks.md`. + +### Ограниченная буферизация + +- SDK в процессе: трассы и логи — очередь до 2048 записей на сигнал, лишнее отбрасывается. Одна отправка — не дольше 5 с. Отправка идёт в фоновых потоках, запросы не ждут Collector. +- Collector: `memory_limiter` (400 МиБ кучи при лимите контейнера 512 МиБ) первым в каждом pipeline, `batch`, у каждого exporter очередь до 200 пачек, повторы 1…30 с не дольше 5 минут, потом отбрасывание. Потери считаются в `otelcol_exporter_send_failed_*`, видны на панели «Конвейер телеметрии». ## Доказательства критериев | Критерий 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 при включённой телеметрии | evidence/test.txt | +| Структура skeleton и контракт не изменены | make check | PASS | evidence/check.txt | +| 3: минимум lab5 работает | make student-test; make db-test; make test-failover; make test-persistence | все тесты OK; failover и persistence PASS | evidence/student-test.txt, db-test.txt, failover.txt, persistence.txt | +| 3: Collector, три хранилища и Grafana в общем стенде, конфиги и provisioning в Git, volumes | make check-stack; make telemetry-persistence | 5 сервисов с закреплёнными версиями, volumes; после перезапуска Prometheus, Loki, Tempo, Grafana — та же трасса, тот же лог, то же значение метрики в прошлом | evidence/stack.txt, telemetry-persistence.txt | +| 3: API и worker отдают OTLP; RPS/errors/duration API, jobs и duration worker в Grafana | make telemetry-check; make dashboard-check | метрики обоих сервисов есть; каждый запрос панелей возвращает данные | evidence/telemetry-check.txt, dashboard-check.txt | +| 3: структурные логи и реальные трассы API и worker | make telemetry-check | лог: event, severity, service.name, trace_id, span_id; трасса с SERVER/PRODUCER/CONSUMER и SQL/S3 | evidence/telemetry-check.txt | +| 3: импортируемый dashboard, не screenshot | make dashboard-check | источники данных и dashboard provisioned (readOnly), панели совпадают с JSON в Git | evidence/dashboard-check.txt | +| 3: низкокардинальные labels, trace/span в логах, нет секретов и тел | make telemetry-check | нет labels с ID, маршруты — шаблоны; текст, пароль и токен — 0 совпадений в Loki и в атрибутах спанов | evidence/telemetry-check.txt | +| 3: контролируемый запрос → trace и лог; job → worker trace и лог | make telemetry-check | X-Request-Id → лог → trace с тем же request_id; задание → логи worker job.retry, job.ready с тем же trace_id | evidence/telemetry-check.txt | +| 3: make test при включённой телеметрии; назначение хранилищ | make test; раздел «Архитектура» | PASS; таблица ролей | evidence/test.txt | +| 4: W3C trace context API → broker → worker; producer/consumer parent-child; цепочка до S3/DB с retry | make telemetry-check; make db-test | одна трасса: SERVER → PRODUCER → CONSUMER (попытка 1, retry, ERROR) → jobs.retry → PRODUCER → CONSUMER (попытка 2, ready) → 4× S3 PutObject, SQL под jobs.complete; связи проверены по span_id | evidence/telemetry-check.txt, db-test.txt | +| 4: p50/p95/p99, доля ошибок, queue depth и возраст, DB pool, saturation worker; запросы и единицы | make dashboard-check | таблица «панель — единица — запрос»; перцентили из histogram | evidence/dashboard-check.txt | +| 4: SLI/SLO и окно; alert rules на error rate и queue lag | infra/prometheus/rules/alerts.yml | 3 SLO (окно 1 ч), HighErrorRate, QueueLagHigh, TelemetryExportFailing | evidence/dashboard-check.txt | +| 4: alerts проверены искусственным отказом, firing → resolved | make incident-worker; make incident-db; make incident-db-down | QueueLagHigh firing через 165 с после остановки worker, resolved через 83 с после запуска; HighErrorRate firing через 140 с после блокировки БД, resolved через 90 с после снятия; при pause postgres firing через ~120 с, resolved через 136 с после unpause | evidence/incident-worker.txt, incident-db.txt, incident-db-down.txt | +| 4: memory limiter, batch, ограниченная очередь; остановка хранилища не ломает API и RAM | make telemetry-outage | 3 мин без Tempo и Loki: 1742 сообщения и 38 загрузок без ошибок, куча Collector до 47 МиБ (< 400), RSS до 175 МиБ, очередь до 85 из 200 пачек, отброшено 0; 60 с без Collector — 550 ответов без ошибок, RSS API 147 → 148 МиБ | evidence/telemetry-outage.txt | +| 4: разбор двух инцидентов и шаги диагностики | раздел «Эксперименты и отказы» | worker остановлен; медленная и недоступная БД против медленного обработчика | evidence/incident-worker.txt, incident-db.txt, incident-db-down.txt | +| Выбранный трек 5 | — | не выбран | — | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Стенд: один ноутбук, Docker Desktop (WSL 2), лимиты контейнеров из `compose.yaml` (api 1 CPU / 512 МиБ, worker 1 CPU / 1 ГиБ, Collector 0.5 CPU / 512 МиБ, хранилища по 1 CPU / 512 МиБ). Нагрузка — `student-tests/traffic.py`: 3 потока пишут сообщения с паузой 0.2–0.3 с, один ещё загружает картинку раз в 5 с. Ошибки не повторяются прозрачно, считается каждый ответ. Метрики отправляются раз в 10 с, Prometheus считает правила раз в 15 с. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Остановлен worker (incident-worker) | API отвечает, задания копятся, возраст растёт, QueueLagHigh firing | 2442 сообщения и 52 загрузки — 201/202; возраст старейшего задания рос на 1 с/с до 170 с; firing через 165 с; в трассе загрузки разрыв send → process 123 с при обработке 2,2 с | resolved через 83 с после запуска worker; все 52 загрузки ready, потерь нет | +| Медленный обработчик, БД здорова (incident-db, A) | длинный server span, короткие SQL, 5xx нет | server span 1510 мс, из них в SQL 1,9 мс; 5xx нет, пул свободен | после снятия точки отказа — сразу | +| Медленная БД: LOCK TABLE messages (incident-db, B) | SQL-спан ~5 с с ошибкой, 503, HighErrorRate | INSERT 5002 мс ERROR (statement_timeout), server span 5012 мс, 503; p95 POST сообщений ~7 с; заняты 3 соединения пула; firing через 140 с | resolved через 90 с после снятия блокировки; 78 запросов получили 503 (клиент может повторить с тем же Idempotency-Key) | +| БД недоступна: pause postgres (incident-db-down) | 5xx только на входе, у приложения нет запросов | готовых реплик 0, HAProxy отвечает 503 сам, у приложения 0 запросов/с; пул занят (10 из 10), ждут соединение до 108 запросов; firing через ~120 с | после unpause реплики готовы за ~15 с, resolved через 136 с (окно 2 мин); подтверждённые записи не потеряны | +| Остановлены Tempo и Loki на 3 мин (telemetry-outage) | API работает, память и очередь ограничены | бизнес-запросы без ошибок, куча Collector до 47 МиБ, очередь до 85 из 200 пачек, TelemetryExportFailing firing через ~135 с | очереди разгрузились за 45 с после запуска; лог и трасса загрузки из середины отказа доехали, отброшено 0 | +| Остановлен Collector на 60 с | API работает, SDK не копит без предела | 538 сообщений и 12 загрузок без ошибок, RSS реплики API 147 → 148 МиБ | телеметрия этих 60 с сверх очереди SDK (2048 записей) потеряна, Collector эту потерю не видит | + +### Инцидент 1: «картинки не обрабатываются» (worker остановлен) + +Симптом: QueueLagHigh firing. Диагностика только по сохранённым наблюдениям: +1. Панель «Возраст старейшего задания» растёт линейно, «Глубина очереди» (ready) растёт. Значит, задания не забирают. +2. «Задания по исходу» — 0 доставок в секунду. При этом RPS и ошибки API в норме: проблема не в API. +3. Логи worker: последнее событие `worker.stopped`, новых нет. +4. Трасса загрузки, сделанной во время отказа: между `send attachments` и `process attachments.process` десятки секунд, сама обработка < 1 с. Задание ждало в очереди, медленной обработки нет. +5. Причина — worker не работает. После `docker compose start worker` backlog уходит, alert resolved. + +### Инцидент 2: «сообщения отправляются с ошибкой» (медленная БД против медленного кода) + +Симптом: HighErrorRate firing или рост p95. +1. Панель «Ошибки: вход и приложение»: 5xx есть у приложения, значит ошибки отдаёт код API, реплики живы. +2. «p95 по маршрутам»: медленный POST `/chats/{chat_id}/messages`. +3. Лог с 5xx (`event=http.request`, severity WARNING) → кнопка «Открыть трассу». +4. В трассе SQL INSERT длится ~5 с со статусом ERROR и занимает почти весь server span. Пул: заняты соединения. Это медленная БД, а не код. +5. Для сравнения медленный код: server span ~1.5 с, все SQL-спаны по миллисекунде, 5xx нет. Время уходит внутри обработчика. +6. Причина — блокировка таблицы (`pg_locks`). После снятия ошибки прекращаются, alert resolved. + +Вариант «БД недоступна»: 5xx есть только на входе, у приложения запросов почти нет, готовых реплик 0, в логах неудачные `/health/ready`, в пуле растёт число ожидающих соединения. Значит, реплики выведены из балансировки, причина — зависимость readiness (PostgreSQL). ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Всё на одном Docker-хосте. Хранилища телеметрии в одном экземпляре без репликации, Collector один: если он упадёт, телеметрия сверх очереди SDK теряется. Потери на стороне SDK не считаются метрикой, только потери Collector. +- Метрики очереди считаются из PostgreSQL: когда недоступна сама БД, они пропадают, и QueueLagHigh в это время ничего не покажет. Эту ситуацию ловит HighErrorRate. +- Серии, пришедшие по OTLP, не получают отметку устаревания: после остановки процесса его последние значения видны в Prometheus ещё до 5 минут. +- CPU и память worker — без дочерних процессов обработки картинок. Лимит контейнера ограничивает их вместе. +- Время до ready считается от начала транзакции загрузки (`attachments.created_at`), а не от COMMIT. Разница — миллисекунды. +- Выборка трасс 100%: для учебной нагрузки это дёшево, на большой нагрузке нужна выборка с сохранением ошибок и медленных (трек 5.1). +- Alerts без доставки наружу (Alertmanager не нужен по заданию). OTLP и хранилища без TLS и аутентификации внутри сети telemetry — это lab7. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..391de23 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,476 @@ +# Стенд lab6: HAProxy (единственная точка входа) -> API x2 -> PostgreSQL (источник истины, метаданные, outbox) +# + Valkey (общий кэш сессий) + S3 SeaweedFS (байты: staging, оригиналы, варианты) +# + RabbitMQ (очередь заданий) -> worker (обработка картинок, отдельный процесс) +# + (с lab6) наблюдаемость: API и worker -> OTLP -> otel-collector -> Prometheus (метрики), +# Loki (логи), Tempo (трассы) -> Grafana (dashboard, provisioning из infra/grafana). +# Запуск: 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), +# telemetry (api, worker, lb -> otel-collector -> prometheus, loki, tempo <- grafana) — обе internal, +# без выхода наружу; ops — только чтобы опубликовать Grafana и Prometheus на 127.0.0.1. +# Наружу: балансировщик 127.0.0.1:8080/8081/8404, Grafana 127.0.0.1:3000, Prometheus 127.0.0.1:9090. +# OTLP (4318), Loki и Tempo наружу не опубликованы. +# У api и worker нет ports и container_name: реплик может быть сколько угодно (deploy.replicas). +name: mtusi-lab6 + +# Сборка образа приложения (один образ для 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:lab6 + env_file: .env + # С lab4 — ключи отдельного S3-пользователя API, с lab5 — адрес брокера (relay outbox). + secrets: [database_url, cache_url, s3_access_key_id, s3_secret_access_key, broker_url] + # С lab6 — сеть telemetry: отправка OTLP в otel-collector (OTEL_* в .env). + networks: [edge, backend, telemetry] + +services: + # Одноразовый сервис: применяет migrations/*.sql и завершается с кодом 0. + # Реплики API и worker стартуют только после него и схему не меняют (нет гонки миграций). + migrate: + image: mtusi-messenger:lab6 + 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:lab6 + pull_policy: never # образ собирается сервисом api, а не скачивается + env_file: .env + command: ["python", "-m", "messenger.worker"] + environment: + CACHE_URL_FILE: "" # кэш сессий worker не нужен + OTEL_SERVICE_NAME: messenger-worker # с lab6: отдельный service.name (у API — messenger-api из .env) + secrets: [database_url, s3_access_key_id, s3_secret_access_key, broker_url] + networks: [backend, telemetry] + 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 — + # чтобы после пересоздания контейнера брокер нашёл свои очереди в том же 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, метрики /metrics (с lab6) + volumes: + - ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + # telemetry (с lab6): Prometheus забирает метрики балансировщика lb:8404/metrics (SLI доступности). + networks: [edge, telemetry] + 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} + + # ---------- наблюдаемость (с lab6) ---------- + + # OpenTelemetry Collector: принимает OTLP/HTTP от API и worker (:4318), ограничивает память и + # буферы, раскладывает сигналы по хранилищам (infra/otel/collector.yaml). Сам ничего не хранит. + # Образ distroless (без shell): healthcheck Docker нет, расширение health_check слушает :13133 внутри сети. + otel-collector: + image: otel/opentelemetry-collector-contrib:0.140.1 + command: ["--config=/etc/otelcol-contrib/config.yaml"] + volumes: + - ./infra/otel/collector.yaml:/etc/otelcol-contrib/config.yaml:ro + networks: [telemetry] + restart: unless-stopped + deploy: + resources: + # memory_limiter в конфиге — 400 МиБ кучи: Collector начинает отказывать раньше, чем его убьёт лимит. + limits: {cpus: "0.50", memory: 512M} + + # Prometheus: хранилище МЕТРИК (volume promdata, 15 дней) и вычисление alert rules. + # Метрики приложения приходят от Collector по OTLP (--web.enable-otlp-receiver), сам он опрашивает + # Collector (:8888) и балансировщик (lb:8404). Опубликован только на 127.0.0.1 — страница alerts. + prometheus: + image: prom/prometheus:v3.7.3 + command: + - --config.file=/etc/prometheus/prometheus.yml + - --storage.tsdb.path=/prometheus + - --storage.tsdb.retention.time=15d + - --web.enable-otlp-receiver + volumes: + - ./infra/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro + - ./infra/prometheus/rules:/etc/prometheus/rules:ro + - promdata:/prometheus + ports: + - "127.0.0.1:9090:9090" + networks: [telemetry, ops] + healthcheck: + test: ["CMD", "wget", "-q", "-T", "2", "-O", "/dev/null", "http://127.0.0.1:9090/-/ready"] + interval: 5s + timeout: 3s + retries: 12 + start_period: 20s + restart: unless-stopped + deploy: + resources: + limits: {cpus: "1.00", memory: 512M} + + # Loki: хранилище ЛОГОВ (volume lokidata, 7 дней). Принимает OTLP-логи от Collector. + loki: + image: grafana/loki:3.5.8 + command: ["-config.file=/etc/loki/loki.yaml"] + volumes: + - ./infra/loki/loki.yaml:/etc/loki/loki.yaml:ro + - lokidata:/loki + networks: [telemetry] + restart: unless-stopped + stop_grace_period: 30s # успеть записать принятые логи на диск (flush_on_shutdown) + deploy: + resources: + limits: {cpus: "1.00", memory: 512M} + + # Tempo пишет данные от пользователя 10001, а новый volume принадлежит root: одноразово отдаём каталог. + tempo-init: + image: grafana/tempo:2.9.0 + user: root + entrypoint: ["chown", "10001:10001", "/var/tempo"] + volumes: ["tempodata:/var/tempo"] + network_mode: none + restart: "no" + deploy: + resources: + limits: {cpus: "0.25", memory: 64M} + + # Tempo: хранилище ТРАСС (volume tempodata, 7 дней). Принимает OTLP-трассы от Collector. + tempo: + image: grafana/tempo:2.9.0 + command: ["-config.file=/etc/tempo/tempo.yaml"] + volumes: + - ./infra/tempo/tempo.yaml:/etc/tempo/tempo.yaml:ro + - tempodata:/var/tempo + networks: [telemetry] + depends_on: + tempo-init: {condition: service_completed_successfully} + restart: unless-stopped + stop_grace_period: 30s # успеть закрыть блок трасс; при SIGKILL данные восстановятся из WAL + deploy: + resources: + limits: {cpus: "1.00", memory: 512M} + + # Grafana: интерфейс и запросы к трём хранилищам. Источники данных и dashboard импортируются из Git + # (infra/grafana/provisioning, infra/grafana/dashboards) при старте — вручную ничего не создаётся. + # http://127.0.0.1:3000, пользователь admin, пароль — secrets/grafana_admin_password. + grafana: + image: grafana/grafana:12.2.1 + environment: + GF_SECURITY_ADMIN_USER: admin + GF_SECURITY_ADMIN_PASSWORD__FILE: /run/secrets/grafana_admin_password + GF_USERS_ALLOW_SIGN_UP: "false" + GF_AUTH_ANONYMOUS_ENABLED: "false" + GF_ANALYTICS_REPORTING_ENABLED: "false" + GF_ANALYTICS_CHECK_FOR_UPDATES: "false" + GF_ANALYTICS_CHECK_FOR_PLUGIN_UPDATES: "false" + GF_NEWS_NEWS_FEED_ENABLED: "false" + GF_PLUGINS_PREINSTALL_DISABLED: "true" # без скачивания плагинов из интернета при старте + secrets: [grafana_admin_password] + volumes: + - ./infra/grafana/provisioning:/etc/grafana/provisioning:ro + - ./infra/grafana/dashboards:/var/lib/grafana/dashboards:ro + - grafanadata:/var/lib/grafana + ports: + - "127.0.0.1:3000:3000" + networks: [telemetry, ops] + depends_on: + prometheus: {condition: service_healthy} + loki: {condition: service_started} + tempo: {condition: service_started} + healthcheck: + test: ["CMD", "wget", "-q", "-T", "2", "-O", "/dev/null", "http://127.0.0.1:3000/api/health"] + interval: 5s + timeout: 3s + retries: 20 + start_period: 30s + restart: unless-stopped + deploy: + resources: + limits: {cpus: "1.00", memory: 512M} + + # Интеграционные тесты хранилища и заданий (откат транзакций, гонки, идемпотентность, 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:lab6 + 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:lab6 + 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: {} + # с lab6: история телеметрии переживает пересоздание контейнеров + promdata: {} + lokidata: {} + tempodata: {} + grafanadata: {} + +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} + grafana_admin_password: {file: ./secrets/grafana_admin_password} + +networks: + edge: {} + backend: + internal: true # хранилища и брокер недоступны снаружи и сами не ходят в интернет + telemetry: + internal: true # OTLP, Loki, Tempo — только внутри стенда + ops: {} # только для публикации Grafana и Prometheus на 127.0.0.1 diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 0000000..af78b3e --- /dev/null +++ b/evidence/check.txt @@ -0,0 +1,2 @@ +python scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. diff --git a/evidence/dashboard-check.txt b/evidence/dashboard-check.txt new file mode 100644 index 0000000..0ed315c --- /dev/null +++ b/evidence/dashboard-check.txt @@ -0,0 +1,55 @@ +python student-tests/check_dashboard.py +1. Grafana 12.2.1: datasources prometheus, loki, tempo — provisioned (readOnly); prometheus, loki health OK; tempo answers a search through Grafana + dashboard 'Messenger lab6: API, worker, очередь, SLO' provisioned from messenger.json, 29 panels (same as the JSON in Git) +2. every panel query against its store: + panel unit series query + SLO-1 доступность API, 1 ч (цель ≥ 99%) percentunit 1 messenger:edge_availability:ratio1h + SLO-2 p95 задержки API, 5 мин (цель < 0.5 с) s 1 messenger:http_latency_p95:5m + SLO-3 вложения ready < 30 с, 1 ч (цель ≥ 95%) percentunit 1 messenger:time_to_ready_under_30s:ratio1h + Alerts: pending / firing none 0 max by (alertname, alertstate) (ALERTS) + RPS по маршрутам reqps 4 sum by (http_route) (rate(http_server_request_duration_seconds_count{job="messenger-api"}[1m])) + Ошибки: вход HAProxy и приложение (доля) percentunit 1 messenger:edge_error_ratio:rate2m + Ошибки: вход HAProxy и приложение (доля) percentunit 0 sum(rate(http_server_request_duration_seconds_count{job="messenger-api",http_response_status_code=~"5.."}[2m])) / sum(rate(http_server_request_duratio + Ошибки: вход HAProxy и приложение (доля) percentunit 0 sum(rate(http_server_request_duration_seconds_count{job="messenger-api",http_response_status_code=~"4.."}[2m])) / sum(rate(http_server_request_duratio + Задержка API p50 / p95 / p99 s 1 histogram_quantile(0.50, sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api"}[5m]))) + Задержка API p50 / p95 / p99 s 1 histogram_quantile(0.95, sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api"}[5m]))) + Задержка API p50 / p95 / p99 s 1 histogram_quantile(0.99, sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api"}[5m]))) + p95 по маршрутам s 4 histogram_quantile(0.95, sum by (le, http_route) (rate(http_server_request_duration_seconds_bucket{job="messenger-api"}[5m]))) + Ответы клиентам по классам (HAProxy) и готовые short 6 sum by (code) (rate(haproxy_frontend_http_responses_total{proxy="api_in"}[1m])) + Ответы клиентам по классам (HAProxy) и готовые short 1 haproxy_backend_active_servers{proxy="api"} + Запросы в обработке short 1 sum by (instance) (http_server_active_requests{job="messenger-api"}) + Глубина очереди (backlog) short 3 max by (state) (messenger_queue_depth{job="messenger-api"}) + Глубина очереди (backlog) short 1 max(messenger_outbox_pending{job="messenger-api"}) + Возраст старейшего задания (lag) s 1 max(messenger_queue_oldest_age_seconds{job="messenger-api"}) + Возраст старейшего задания (lag) s 1 max(messenger_outbox_oldest_age_seconds{job="messenger-api"}) + Задания по исходу ops 1 sum by (outcome) (rate(messenger_jobs_processed_total[1m])) + Обработка задания p50 / p95 / p99 (worker) s 0 histogram_quantile(0.50, sum by (le) (rate(messenger_job_duration_seconds_bucket{outcome="ready"}[5m]))) + Обработка задания p50 / p95 / p99 (worker) s 0 histogram_quantile(0.95, sum by (le) (rate(messenger_job_duration_seconds_bucket{outcome="ready"}[5m]))) + Обработка задания p50 / p95 / p99 (worker) s 0 histogram_quantile(0.99, sum by (le) (rate(messenger_job_duration_seconds_bucket{outcome="ready"}[5m]))) + Время до ready p50 / p95 / p99 s 0 histogram_quantile(0.50, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket[5m]))) + Время до ready p50 / p95 / p99 s 0 histogram_quantile(0.95, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket[5m]))) + Время до ready p50 / p95 / p99 s 0 histogram_quantile(0.99, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket[5m]))) + Насыщение worker percentunit 1 sum(messenger_worker_busy) / sum(messenger_worker_capacity) + Пул соединений с БД short 4 sum by (db_client_connection_pool_name, db_client_connection_state) (db_client_connection_count) + Пул соединений с БД short 2 sum by (db_client_connection_pool_name) (db_client_connection_pending_requests) + Пул соединений с БД short 2 sum by (db_client_connection_pool_name) (db_client_connection_max) + CPU процессов (ядер) short 3 sum by (job, instance) (rate(process_cpu_time_seconds_total{job=~"messenger-.*"}[1m])) + CPU процессов (ядер) short 1 rate(otelcol_process_cpu_seconds_total[1m]) + Память процессов (RSS) bytes 3 process_memory_usage_bytes{job=~"messenger-.*"} + Память процессов (RSS) bytes 1 otelcol_process_memory_rss_bytes + Память процессов (RSS) bytes 1 otelcol_process_runtime_heap_alloc_bytes + Принято / отправлено / потеряно (в секунду) short 1 sum(rate(otelcol_receiver_accepted_spans_total[1m])) + Принято / отправлено / потеряно (в секунду) short 1 sum(rate(otelcol_exporter_sent_spans_total[1m])) + Принято / отправлено / потеряно (в секунду) short 1 sum(rate(otelcol_exporter_send_failed_spans_total[1m])) + Принято / отправлено / потеряно (в секунду) short 1 sum(rate(otelcol_receiver_accepted_log_records_total[1m])) + Принято / отправлено / потеряно (в секунду) short 1 sum(rate(otelcol_exporter_sent_log_records_total[1m])) + Принято / отправлено / потеряно (в секунду) short 1 sum(rate(otelcol_exporter_send_failed_log_records_total[1m])) + Принято / отправлено / потеряно (в секунду) short 1 sum(rate(otelcol_exporter_sent_metric_points_total[1m])) + Принято / отправлено / потеряно (в секунду) short 1 sum(rate(otelcol_exporter_send_failed_metric_points_total[1m])) + Очереди exporter (пачки) short 3 sum by (exporter) (otelcol_exporter_queue_size) + Очереди exporter (пачки) short 1 max(otelcol_exporter_queue_capacity) + Логи API и worker (предупреждения и ошибки) - 20 {service_name=~"messenger-api|messenger-worker"} | severity_text=~"WARN.*|ERROR|CRITICAL" + Трассы загрузок (последние) - 5 { kind = server && span.messenger.attachment.id != "" } + all queries succeeded; empty (allowed: failure-only panels): 9 +3. alert rules loaded and healthy: HighErrorRate (inactive, for 60 s), QueueLagHigh (inactive, for 60 s), TelemetryExportFailing (inactive, for 60 s) +PASS: provisioning from Git, every panel query returns data from Prometheus/Loki/Tempo, alert rules loaded diff --git a/evidence/db-test.txt b/evidence/db-test.txt new file mode 100644 index 0000000..fae94ed --- /dev/null +++ b/evidence/db-test.txt @@ -0,0 +1,63 @@ +docker compose --profile tools run --rm db-test + Container mtusi-lab6-postgres-1 Running + Container mtusi-lab6-postgres-1 Waiting + Container mtusi-lab6-postgres-1 Healthy + Container mtusi-lab6-db-test-run-168f826f7822 Creating + Container mtusi-lab6-db-test-run-168f826f7822 Created +test_1_replay_after_snapshot_keeps_staging (test_cleanup.CleanupRaceTest.test_1_replay_after_snapshot_keeps_staging) ... ok +test_2_cleanup_first_then_replay_waits_and_refuses (test_cleanup.CleanupRaceTest.test_2_cleanup_first_then_replay_waits_and_refuses) ... + snapshot -> replay (queued) -> cleanup: kept [('staging/64162cff-1151-4ba4-9246-def8ec904a03', 'current_work')], nothing deleted + + 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) ... + replay holds the lock -> cleanup waited -> kept [('staging/714f466f-b839-470d-8364-a66a4006e923', 'current_work')] +ok +test_4_upload_in_progress_is_skipped (test_cleanup.CleanupRaceTest.test_4_upload_in_progress_is_skipped) ... + 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 +ok + + 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 +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) ... ok +test_concurrent_same_idempotency_key_creates_one_row (test_store.StoreIntegrationTest.test_concurrent_same_idempotency_key_creates_one_row) ... + 20 параллельных create_user: 1 создан, 19 получили Conflict (409) + + 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 не осталось + + INSERT сообщения от не-участника напрямую в БД: ForeignKeyViolation +ok +test_migrations_rerun_is_noop (test_store.StoreIntegrationTest.test_migrations_rerun_is_noop) ... + schema_migrations: ['001_core', '002_sessions', '003_text_as_bytes', '004_message_idempotency', '005_attachments', '006_jobs']; повторный migrate() ничего не применил +ok +test_old_version_insert_without_key_still_works (test_store.StoreIntegrationTest.test_old_version_insert_without_key_still_works) ... ok +test_same_key_other_body_is_conflict (test_store.StoreIntegrationTest.test_same_key_other_body_is_conflict) ... + INSERT как в lab2 (без ключа) после миграции 004 работает: старая версия совместима со схемой + + тот же ключ с другим телом: Conflict (409), в базе по-прежнему одна строка +ok +test_complete_returns_time_to_ready (test_trace_context.TraceContextTest.test_complete_returns_time_to_ready) ... ok +test_upload_span_and_retries_stay_in_one_trace (test_trace_context.TraceContextTest.test_upload_span_and_retries_stay_in_one_trace) ... ok + +---------------------------------------------------------------------- +Ran 24 tests in 3.396s + +OK diff --git a/evidence/failover.txt b/evidence/failover.txt new file mode 100644 index 0000000..96f23c8 --- /dev/null +++ b/evidence/failover.txt @@ -0,0 +1,4 @@ +python tests/resilience.py --mode failover --action-script "scripts/stop-one.cmd" --base-url "http://127.0.0.1:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 121, "failed_attempts": 0, "first_recovery_seconds": 5.828} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/incident-db-down.txt b/evidence/incident-db-down.txt new file mode 100644 index 0000000..3171191 --- /dev/null +++ b/evidence/incident-db-down.txt @@ -0,0 +1,28 @@ +python student-tests/incident_db.py --down +C. DB unavailable: docker compose pause postgres + t= 20s edge_5xx_ratio= 0.011 app_5xx/s= 0 app_rps=12.787 p95_messages= 0.031s pool_used= 1 pool_waiting= 0 ready_replicas= 2 HighErrorRate=inactive http={'201': 258} + t=21s postgres paused + t= 21s edge_5xx_ratio= 0.011 app_5xx/s= 0 app_rps=12.787 p95_messages= 0.031s pool_used= 1 pool_waiting= 0 ready_replicas= 2 HighErrorRate=inactive http={'201': 264} + t= 36s edge_5xx_ratio= 0.002 app_5xx/s= 0 app_rps= 9.775 p95_messages= 0.043s pool_used= 10 pool_waiting= 5 ready_replicas= 0 HighErrorRate=inactive http={'201': 264} + t= 51s edge_5xx_ratio= 0 app_5xx/s= 0 app_rps= 6.614 p95_messages= 0.047s pool_used= 10 pool_waiting= 20 ready_replicas= 0 HighErrorRate=inactive http={'201': 264, 'timeout': 3, '503': 137} + t= 66s edge_5xx_ratio= 0 app_5xx/s= 0 app_rps= 1.831 p95_messages= 0.045s pool_used= 10 pool_waiting= 34 ready_replicas= 0 HighErrorRate=inactive http={'201': 264, 'timeout': 3, '503': 342} + t= 81s edge_5xx_ratio= 0.117 app_5xx/s= 0 app_rps= 0 p95_messages= nans pool_used= 10 pool_waiting= 49 ready_replicas= 0 HighErrorRate=pending http={'201': 264, 'timeout': 3, '503': 548} + t= 96s edge_5xx_ratio= 0.302 app_5xx/s= 0 app_rps= 0 p95_messages= nans pool_used= 10 pool_waiting= 64 ready_replicas= 0 HighErrorRate=pending http={'201': 264, 'timeout': 3, '503': 754} + t= 111s edge_5xx_ratio= 0.485 app_5xx/s= 0 app_rps= 0 p95_messages= nans pool_used= 10 pool_waiting= 78 ready_replicas= 0 HighErrorRate=pending http={'201': 264, 'timeout': 3, '503': 959} + t= 126s edge_5xx_ratio= 0.658 app_5xx/s= 0 app_rps= 0 p95_messages= nans pool_used= 10 pool_waiting= 93 ready_replicas= 0 HighErrorRate=pending http={'201': 264, 'timeout': 3, '503': 1165} + t= 141s edge_5xx_ratio= 0.822 app_5xx/s= 0 app_rps= 0 p95_messages= nans pool_used= 10 pool_waiting=108 ready_replicas= 0 HighErrorRate=firing http={'201': 264, 'timeout': 3, '503': 1370} + HighErrorRate FIRING at t=141s; ready replicas 0, app requests/s 0: 503 comes from HAProxy itself — no replica passes /health/ready (PostgreSQL) + logs: 111 failed /health/ready checks in 5 min, e.g. GET /health/ready -> 503 (1003.6 ms) request_id=9861289a32724b64ba89d8539e657c8e + t=142s postgres unpaused + t= 142s edge_5xx_ratio= 0.997 app_5xx/s= 0 app_rps= 0 p95_messages= nans pool_used= 10 pool_waiting=108 ready_replicas= 0 HighErrorRate=firing http={'201': 264, 'timeout': 3, '503': 1382} + t= 157s edge_5xx_ratio= 1 app_5xx/s= 0 app_rps= 2.878 p95_messages= 0.048s pool_used= 2 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 445, 'timeout': 3, '503': 1394} + t= 172s edge_5xx_ratio= 0.89 app_5xx/s= 0 app_rps= 5.495 p95_messages= 0.039s pool_used= 2 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 643, 'timeout': 3, '503': 1394} + t= 187s edge_5xx_ratio= 0.749 app_5xx/s= 0 app_rps=10.472 p95_messages= 0.031s pool_used= 1 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 828, 'timeout': 3, '503': 1394} + t= 202s edge_5xx_ratio= 0.614 app_5xx/s= 0 app_rps=12.849 p95_messages= 0.025s pool_used= 0 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 1023, 'timeout': 3, '503': 1394} + t= 217s edge_5xx_ratio= 0.469 app_5xx/s= 0 app_rps=12.811 p95_messages= 0.025s pool_used= 0 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 1220, 'timeout': 3, '503': 1394} + t= 232s edge_5xx_ratio= 0.324 app_5xx/s= 0 app_rps= 12.79 p95_messages= 0.025s pool_used= 0 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 1418, 'timeout': 3, '503': 1394} + t= 247s edge_5xx_ratio= 0.176 app_5xx/s= 0 app_rps=12.886 p95_messages= 0.037s pool_used= 0 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 1607, 'timeout': 3, '503': 1394} + t= 263s edge_5xx_ratio= 0.027 app_5xx/s= 0 app_rps=12.876 p95_messages= 0.035s pool_used= 0 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 1803, 'timeout': 3, '503': 1394} + t= 278s edge_5xx_ratio= 0 app_5xx/s= 0 app_rps=12.937 p95_messages= 0.034s pool_used= 0 pool_waiting= 0 ready_replicas= 2 HighErrorRate=inactive http={'201': 2003, 'timeout': 3, '503': 1394} + HighErrorRate RESOLVED at t=278s (136 s after unpause); http codes: {'201': 2003, 'timeout': 3, '503': 1394} +PASS: DB unavailable -> 5xx only at the entry (HAProxy), HighErrorRate firing -> resolved diff --git a/evidence/incident-db.txt b/evidence/incident-db.txt new file mode 100644 index 0000000..71b7433 --- /dev/null +++ b/evidence/incident-db.txt @@ -0,0 +1,41 @@ +python student-tests/incident_db.py +A. slow HTTP handler, healthy DB (fault api_slow_handler=1.5 s in every api replica) + request 5251b25d1bb54d0b92d0ddf565ecf373 -> 201; log event=http.request severity=INFO; trace b3002e4e6c367387a94d2cfe9c1c19f4 + messenger-api SERVER POST /api/v1/chats/{chat_id}/messages 1509.8 ms route=/api/v1/chats/{chat_id}/messages status_code=201 + messenger-api CLIENT SQL messenger 0.6 ms + messenger-api CLIENT SQL INSERT 1.3 ms + server span 1510 ms, of it in SQL 1.9 ms (slowest SQL INSERT 1.3 ms): the time is spent in the handler, not in the DB + metrics: p95 POST messages = 0.073 s, app 5xx/s = 0, pool waiting = 0 +B. slow DB: a session holds LOCK TABLE messages; POST message waits until statement_timeout (5 s) -> 503 + t= 20s edge_5xx_ratio= 0 app_5xx/s= 0 app_rps= 4.375 p95_messages= 0.042s pool_used= 0 pool_waiting= 0 ready_replicas= 2 HighErrorRate=inactive http={'201': 264} + t=20s lock taken + request 2bf9d5bf4786487ab0099233a896a582 -> 503; log event=http.request severity=WARN; trace 0c50ab02599e0932544e54b368230bd6 + messenger-api SERVER POST /api/v1/chats/{chat_id}/messages 5012.5 ms ERROR route=/api/v1/chats/{chat_id}/messages status_code=503 + messenger-api CLIENT SQL messenger 0.5 ms + messenger-api CLIENT SQL SELECT 1.6 ms + messenger-api CLIENT SQL messenger 0.5 ms + messenger-api CLIENT SQL INSERT 5001.6 ms ERROR + server span 5012 ms, of it in SQL 5004 ms; slowest SQL INSERT 5002 ms status ERROR: the DB is slow + t= 40s edge_5xx_ratio= 0 app_5xx/s= 0.095 app_rps= 5.429 p95_messages= 0.033s pool_used= 2 pool_waiting= 0 ready_replicas= 2 HighErrorRate=inactive http={'201': 267, '503': 9} + t= 55s edge_5xx_ratio= 0.009 app_5xx/s= 0.264 app_rps= 5.6 p95_messages= 0.048s pool_used= 3 pool_waiting= 0 ready_replicas= 2 HighErrorRate=inactive http={'201': 267, '503': 18} + t= 70s edge_5xx_ratio= 0.027 app_5xx/s= 0.422 app_rps= 1.661 p95_messages= 7.008s pool_used= 3 pool_waiting= 0 ready_replicas= 2 HighErrorRate=inactive http={'201': 267, '503': 27} + t= 85s edge_5xx_ratio= 0.055 app_5xx/s= 0.578 app_rps= 0.578 p95_messages= 7.375s pool_used= 3 pool_waiting= 0 ready_replicas= 2 HighErrorRate=inactive http={'201': 267, '503': 36} + t= 100s edge_5xx_ratio= 0.1 app_5xx/s= 0.599 app_rps= 0.599 p95_messages= 7.375s pool_used= 3 pool_waiting= 0 ready_replicas= 2 HighErrorRate=pending http={'201': 267, '503': 45} + t= 115s edge_5xx_ratio= 0.117 app_5xx/s= 0.599 app_rps= 0.599 p95_messages= 7.375s pool_used= 3 pool_waiting= 0 ready_replicas= 2 HighErrorRate=pending http={'201': 267, '503': 54} + t= 130s edge_5xx_ratio= 0.163 app_5xx/s= 0.6 app_rps= 0.6 p95_messages= 7.375s pool_used= 3 pool_waiting= 0 ready_replicas= 2 HighErrorRate=pending http={'201': 267, '503': 63} + t= 145s edge_5xx_ratio= 0.655 app_5xx/s= 0.6 app_rps= 0.6 p95_messages= 7.375s pool_used= 2 pool_waiting= 0 ready_replicas= 2 HighErrorRate=pending http={'201': 267, '503': 69} + t= 160s edge_5xx_ratio= 1 app_5xx/s= 0.54 app_rps= 0.54 p95_messages= 7.375s pool_used= 3 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 267, '503': 78} + HighErrorRate FIRING at t=160s (140 s after the lock) + t=161s lock released (pg_cancel_backend) + t= 161s edge_5xx_ratio= 1 app_5xx/s= 0.54 app_rps= 0.54 p95_messages= 7.375s pool_used= 3 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 270, '503': 78} + t= 176s edge_5xx_ratio= 1 app_5xx/s= 0.465 app_rps= 1.894 p95_messages= 6.991s pool_used= 0 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 466, '503': 78} + t= 191s edge_5xx_ratio= 0.36 app_5xx/s= 0.235 app_rps= 6.123 p95_messages= 2.043s pool_used= 4 pool_waiting= 2 ready_replicas= 2 HighErrorRate=firing http={'201': 616, '503': 78} + t= 206s edge_5xx_ratio= 0.143 app_5xx/s= 0.074 app_rps=10.397 p95_messages= 0.04s pool_used= 0 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 815, '503': 78} + t= 221s edge_5xx_ratio= 0.081 app_5xx/s= 0 app_rps=12.217 p95_messages= 0.025s pool_used= 0 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 1013, '503': 78} + t= 236s edge_5xx_ratio= 0.045 app_5xx/s= 0 app_rps=12.284 p95_messages= 0.025s pool_used= 0 pool_waiting= 0 ready_replicas= 2 HighErrorRate=firing http={'201': 1212, '503': 78} + t= 251s edge_5xx_ratio= 0.024 app_5xx/s= 0 app_rps=13.186 p95_messages= 0.024s pool_used= 1 pool_waiting= 0 ready_replicas= 2 HighErrorRate=inactive http={'201': 1410, '503': 78} + HighErrorRate RESOLVED at t=251s (90 s after the release); http codes: {'201': 1410, '503': 78} +Summary: how to tell them apart + slow handler: server span 1510 ms, SQL 2 ms, no 5xx, pool free + slow DB: server span 5012 ms, SQL 5004 ms (ERROR, statement timeout), 5xx, pool connections busy; HighErrorRate firing in 140 s, resolved 90 s after the fix +PASS: slow DB vs slow handler distinguished by trace (time in SQL spans) and metrics (5xx, pool); HighErrorRate firing -> resolved diff --git a/evidence/incident-worker.txt b/evidence/incident-worker.txt new file mode 100644 index 0000000..e9dfb35 --- /dev/null +++ b/evidence/incident-worker.txt @@ -0,0 +1,46 @@ +python student-tests/incident_worker.py +1. baseline (worker running): + t= 15s ready= 0 oldest_age= 0s worker_deliveries/s= 0.06 worker_busy= 0 QueueLagHigh=inactive http={'201': 137, 'upload 202': 2} +2. t=18s docker compose stop worker; uploads continue + t= 19s ready= 0 oldest_age= 0s worker_deliveries/s= 0.07 worker_busy= 0 QueueLagHigh=inactive http={'201': 168, 'upload 202': 3} + t= 34s ready= 0 oldest_age= 0s worker_deliveries/s= 0.06 worker_busy= 0 QueueLagHigh=inactive http={'201': 305, 'upload 202': 6} + t= 49s ready= 4 oldest_age= 19.49s worker_deliveries/s= 0.06 worker_busy= 0 QueueLagHigh=inactive http={'201': 440, 'upload 202': 9} + t= 64s ready= 6 oldest_age= 29.49s worker_deliveries/s= 0.02 worker_busy= 0 QueueLagHigh=inactive http={'201': 574, 'upload 202': 12} + t= 79s ready= 10 oldest_age= 49.49s worker_deliveries/s= — worker_busy= 0 QueueLagHigh=inactive http={'201': 711, 'upload 202': 15} + t= 94s ready= 12 oldest_age= 59.5s worker_deliveries/s= — worker_busy= 0 QueueLagHigh=inactive http={'201': 846, 'upload 202': 18} + t= 109s ready= 16 oldest_age= 79.5s worker_deliveries/s= — worker_busy= 0 QueueLagHigh=inactive http={'201': 984, 'upload 202': 21} + t= 124s ready= 20 oldest_age= 99.51s worker_deliveries/s= — worker_busy= 0 QueueLagHigh=pending http={'201': 1121, 'upload 202': 23} + t= 124s ready= 20 oldest_age= 99.51s worker_deliveries/s= — worker_busy= 0 QueueLagHigh=pending http={'201': 1121, 'upload 202': 23} + t= 139s ready= 22 oldest_age=109.52s worker_deliveries/s= — worker_busy= 0 QueueLagHigh=pending http={'201': 1258, 'upload 202': 26} + t= 154s ready= 25 oldest_age=129.52s worker_deliveries/s= — worker_busy= 0 QueueLagHigh=pending http={'201': 1393, 'upload 202': 29} + t= 169s ready= 27 oldest_age=139.86s worker_deliveries/s= — worker_busy= 0 QueueLagHigh=pending http={'201': 1519, 'upload 202': 32} + t= 184s ready= 31 oldest_age=159.55s worker_deliveries/s= — worker_busy= 0 QueueLagHigh=firing http={'201': 1654, 'upload 202': 35} +3. QueueLagHigh pending at t=124s, FIRING at t=184s (165 s after the worker stopped) +4. t=189s docker compose start worker + t= 197s ready= 33 oldest_age=169.93s worker_deliveries/s= — worker_busy= 0 QueueLagHigh=firing http={'201': 1767, 'upload 202': 38} + t= 212s ready= 31 oldest_age=159.33s worker_deliveries/s= — worker_busy= 1 QueueLagHigh=firing http={'201': 1902, 'upload 202': 41} + t= 227s ready= 19 oldest_age= 96.24s worker_deliveries/s= 0.38 worker_busy= 1 QueueLagHigh=firing http={'201': 2036, 'upload 202': 44} + t= 242s ready= 11 oldest_age= 54.98s worker_deliveries/s= 0.63 worker_busy= 1 QueueLagHigh=firing http={'201': 2174, 'upload 202': 46} + t= 257s ready= 1 oldest_age= 3.16s worker_deliveries/s= 0.82 worker_busy= 0.5 QueueLagHigh=firing http={'201': 2308, 'upload 202': 49} + t= 272s ready= 0 oldest_age= 0s worker_deliveries/s= 0.62 worker_busy= 0 QueueLagHigh=inactive http={'201': 2442, 'upload 202': 52} + QueueLagHigh RESOLVED at t=272s (83 s after the worker started) + all 52 uploads of the run are ready (none lost); final http codes: {'201': 2442, 'upload 202': 52} +5. diagnosis from stored telemetry: + metrics: max oldest_age over 10 min = 170 s; worker deliveries/s fell to 0 while API kept answering 2xx — the queue is not drained, the API is healthy + logs: worker.started (cf67239815a8); worker.stopped (cf67239815a8); worker.started (cf67239815a8) + trace 42f0e6b4e45735295a6ddcff6dca33f of upload 97bd8671-fd20-4454-8d91-54bfd61c9db2 made during the outage: send -> process gap 123 s (message waited in the queue), processing itself 2.19 s + messenger-api SERVER POST /api/v1/chats/{chat_id}/attachments 30.0 ms route=/api/v1/chats/{chat_id}/attachments status_code=202 + messenger-api CLIENT S3.PutObject 10.1 ms method=PutObject + messenger-api INTERNAL BackgroundTask nudge 0.8 ms + messenger-api PRODUCER send attachments 4.7 ms attempt=1 + messenger-worker CONSUMER process attachments.process 2190.9 ms attempt=1 outcome=ready + messenger-worker INTERNAL jobs.claim 6.8 ms + messenger-worker CLIENT S3.GetObject 8.1 ms method=GetObject + messenger-worker INTERNAL image.process 2066.8 ms + messenger-worker CLIENT S3.PutObject 10.5 ms method=PutObject + messenger-worker CLIENT S3.PutObject 8.1 ms method=PutObject + messenger-worker CLIENT S3.PutObject 8.3 ms method=PutObject + messenger-worker CLIENT S3.PutObject 8.0 ms method=PutObject + messenger-worker INTERNAL jobs.complete 56.7 ms + messenger-worker CLIENT S3.DeleteObject 4.3 ms method=DeleteObject +PASS: worker stopped -> oldest job age grew -> QueueLagHigh firing in 165 s; worker started -> backlog drained, alert resolved in 83 s; no uploads lost diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 0000000..8ccb26a --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,3 @@ +python tests/resilience.py --mode persistence --action-script "scripts/restart.cmd" --base-url "http://127.0.0.1:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/stack.txt b/evidence/stack.txt new file mode 100644 index 0000000..ecfe789 --- /dev/null +++ b/evidence/stack.txt @@ -0,0 +1,32 @@ +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 -> ['58a74eb2cca0', '8e29adaece1b'] (deploy.replicas = 2) + +service container cpus memory published ports networks +valkey 12b7cd0a1630 0.50 128Mi - backend +lb 188cafe602f3 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, telemetry +prometheus 32f969b6e0f8 1.00 512Mi 127.0.0.1:9090->9090/tcp ops, telemetry +api 58a74eb2cca0 1.00 512Mi - backend, edge, telemetry +grafana 5dcc8779d9a0 1.00 512Mi 127.0.0.1:3000->3000/tcp ops, telemetry +tempo 77fb8493dbae 1.00 512Mi - telemetry +s3 7c0244f96be0 0.50 512Mi - backend +api 8e29adaece1b 1.00 512Mi - backend, edge, telemetry +postgres 99e389223400 1.00 512Mi - backend +loki a25bf9eaddb8 1.00 512Mi - telemetry +otel-collector aaf7048fd9ed 0.50 512Mi - telemetry +worker cf67239815a8 1.00 1024Mi - backend, telemetry +broker eb2e18aeb0c3 1.00 512Mi - backend + +published: only lb, grafana (3000) and prometheus (9090), only on 127.0.0.1 (api replicas, OTLP, Loki, Tempo 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 (+telemetry); api -> edge + backend + telemetry; postgres, valkey, s3, broker -> 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 +telemetry: otel-collector otel/opentelemetry-collector-contrib:0.140.1; prometheus prom/prometheus:v3.7.3; loki grafana/loki:3.5.8; tempo grafana/tempo:2.9.0; grafana grafana/grafana:12.2.1 + volumes promdata, lokidata, tempodata, grafanadata; OTLP/Loki/Tempo only on internal network telemetry; worker service.name=messenger-worker +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; grafana -> grafana_admin_password; otel-collector -> none; prometheus -> none; loki -> none; tempo -> none +images: lb haproxy:3.2.25-alpine; api mtusi-messenger:lab6; worker mtusi-messenger:lab6; 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; collector and three telemetry stores + Grafana pinned, with volumes, OTLP only on the internal network diff --git a/evidence/student-test.txt b/evidence/student-test.txt new file mode 100644 index 0000000..0902e43 --- /dev/null +++ b/evidence/student-test.txt @@ -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 44.119s + +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 на ['58a74eb2cca0', '8e29adaece1b'] + + 20 x GET /users/me с одним токеном -> реплики {'8e29adaece1b': 10, '58a74eb2cca0': 10}; это ID запущенных контейнеров api, повторный вход не нужен + + 10 x GET /users/me через реплики {'8e29adaece1b': 5, '58a74eb2cca0': 5}: попаданий в кэш +20, промахов +0 — кэш общий + + сообщение записала реплика 8e29adaece1b, сразу прочитали ['58a74eb2cca0', '8e29adaece1b'] + + с тем же ключом: сначала 400 (пустой текст), потом 201 — ошибка ключ не заняла + + тот же JSON с другими пробелами и переносами -> тот же 201 и то же сообщение + + нет ключа, пустой, 129 символов, пробел, '/', кириллица -> 400; 128 символов и ._:- -> 201 + + тот же ключ у другого пользователя и в другом чате -> независимые сообщения + + 10 одновременных разных тел с одним ключом: 201 x1, 409 x9, в истории 1 сообщение + + 20 одновременных POST с одним ключом через реплики {'58a74eb2cca0': 10, '8e29adaece1b': 10}: все 201 с одним id, в истории 1 сообщение + + повтор: посторонний -> 404, после logout -> 401, после нового входа -> то же сообщение + + 1 запрос + 4 повтора через реплики ['58a74eb2cca0', '8e29adaece1b']: 201 и то же сообщение, в истории 1 + + другой текст с тем же ключом -> 409 conflict, второе сообщение не создано diff --git a/evidence/telemetry-check.txt b/evidence/telemetry-check.txt new file mode 100644 index 0000000..379ff6d --- /dev/null +++ b/evidence/telemetry-check.txt @@ -0,0 +1,44 @@ +python student-tests/check_telemetry.py +1. POST message: X-Request-Id=8be49d40c84c497aba6d04adf33a859c -> Loki: event=http.request severity=INFO service=messenger-api instance=58a74eb2cca0 trace_id=6f3559ea6df4de9a35ecacef79f9661e span_id=ae53b8f0874f223b + Tempo: trace 6f3559ea6df4de9a35ecacef79f9661e, server span ae53b8f0874f223b (request_id matches), 2 SQL spans: + messenger-api SERVER POST /api/v1/chats/{chat_id}/messages 29.7 ms route=/api/v1/chats/{chat_id}/messages status_code=201 + messenger-api CLIENT SQL messenger 0.5 ms + messenger-api CLIENT SQL INSERT 1.4 ms +2. upload with one injected transient failure: attachment_id=81376ed2-3d0c-41d4-8048-41365092615d -> 202 queued + one trace f8722248c26bcadcb87de24591b1faa8: SERVER -> PRODUCER -> CONSUMER(attempt 1, retry, ERROR) -> jobs.retry -> PRODUCER(attempt 2) -> CONSUMER(attempt 2, ready) -> 4 x S3 PutObject, SQL under jobs.complete + messenger-api SERVER POST /api/v1/chats/{chat_id}/attachments 36.1 ms route=/api/v1/chats/{chat_id}/attachments status_code=202 + messenger-api CLIENT S3.PutObject 9.4 ms method=PutObject + messenger-api INTERNAL BackgroundTask nudge 1.0 ms + messenger-api PRODUCER send attachments 6.8 ms attempt=1 + messenger-worker CONSUMER process attachments.process 32.7 ms ERROR attempt=1 outcome=retry + messenger-worker INTERNAL jobs.claim 8.5 ms + messenger-worker CLIENT S3.GetObject 7.5 ms method=GetObject + messenger-worker INTERNAL jobs.retry 10.2 ms error_code=storage_unavailable + messenger-api PRODUCER send attachments 8.5 ms attempt=2 + messenger-worker CONSUMER process attachments.process 1075.2 ms attempt=2 outcome=ready + messenger-worker INTERNAL jobs.claim 13.7 ms + messenger-worker CLIENT S3.GetObject 5.4 ms method=GetObject + messenger-worker INTERNAL image.process 1000.5 ms + messenger-worker CLIENT S3.PutObject 10.0 ms method=PutObject + messenger-worker CLIENT S3.PutObject 7.3 ms method=PutObject + messenger-worker CLIENT S3.PutObject 7.3 ms method=PutObject + messenger-worker CLIENT S3.PutObject 6.8 ms method=PutObject + messenger-worker INTERNAL jobs.complete 9.7 ms + messenger-worker CLIENT S3.DeleteObject 4.4 ms method=DeleteObject + Loki by trace_id: worker events ['job.retry', 'job.ready']; api events ['attachment.accepted', 'http.request'] +3. metrics of the application in Prometheus: + HTTP requests (counter, method/route/code): 6 series; {'http_request_method': 'POST', 'http_response_status_code': '201', 'http_route': '/api/v1/chats/{chat_id}/messages'}=5, {'http_request_method': 'GET', 'http_response_status_code': '200', 'http_route': '/api/v1/chats/{ch + HTTP duration histogram buckets: 1 series; {}=495 + jobs processed by outcome: 2 series; {'messenger_job_type': 'attachment.process', 'outcome': 'ready'}=2, {'messenger_job_type': 'attachment.process', 'outcome': 'retry'}=1 + job duration histogram: 2 series; {'outcome': 'ready'}=2, {'outcome': 'retry'}=1 + time to ready histogram: 1 series; {}=2 + queue depth: 3 series; {'queue': 'attachments.process', 'state': 'ready'}=0, {'queue': 'attachments.process', 'state': 'delayed'}=0, {'queue': 'attachments.process', 'state': 'processing'}=0 + oldest job age: 1 series; {'queue': 'attachments.process'}=0 + DB pool: 4 series; {'db_client_connection_state': 'used', 'job': 'messenger-worker'}=0, {'db_client_connection_state': 'idle', 'job': 'messenger-worker'}=2, {'db_client_connection_state': 'used', 'job': 'messenger-api'}=0 + worker busy/capacity: 1 series; {}=2 + process CPU: 2 series; {'job': 'messenger-worker'}=4.72, {'job': 'messenger-api'}=18.57 + process RAM: 2 series; {'job': 'messenger-worker'}=1.0086e+08, {'job': 'messenger-api'}=2.75915e+08 + 1523 series of messenger-api/worker; label names: __name__, db_client_connection_pool_name, db_client_connection_state, deployment_environment_name, http_request_method, http_response_status_code, http_route, instance, job, le, messenger_job_type, network_protocol_version, outcome, queue, service_version, state, telemetry_sdk_language, telemetry_sdk_name, telemetry_sdk_version, type, url_scheme + no ID labels; http_route values are templates: /api/v1/attachments/{attachment_id}, /api/v1/attachments/{attachment_id}/content, /api/v1/auth/sessions, /api/v1/auth/sessions/current, /api/v1/chats, /api/v1/chats/{chat_id}, /api/v1/chats/{chat_id}/attachments, /api/v1/chats/{chat_id}/messages, /api/v1/users, /api/v1/users/me +4. message text, password and session token: 0 hits in Loki (30 min) and in span attributes; no query strings / Authorization in spans +PASS: request -> log -> trace by X-Request-Id/trace_id; upload -> publish -> consume -> retry -> S3/DB in one trace with parent-child links; app metrics without ID labels; no secrets or message bodies in telemetry diff --git a/evidence/telemetry-outage.txt b/evidence/telemetry-outage.txt new file mode 100644 index 0000000..e9e4a02 --- /dev/null +++ b/evidence/telemetry-outage.txt @@ -0,0 +1,27 @@ +python student-tests/telemetry_outage.py +1. baseline (exporter queue capacity 200 batches, memory_limiter 400 MiB heap, container limit 512 MiB): + t= 15s collector heap= 42.5 rss= 165.7 MiB queues={'loki': 0, 'prometheus': 0, 'tempo': 0} send_failed_total=0 TelemetryExportFailing=inactive http={'201': 136, 'upload 202': 2} +2. t=17s docker compose stop tempo loki (traces and logs stores) + t= 32s collector heap= 27.2 rss= 169.6 MiB queues={'loki': 3, 'prometheus': 0, 'tempo': 3} send_failed_total=0 TelemetryExportFailing=inactive http={'201': 288, 'upload 202': 6} + t= 47s collector heap= 33.6 rss= 169.6 MiB queues={'loki': 11, 'prometheus': 0, 'tempo': 11} send_failed_total=0 TelemetryExportFailing=inactive http={'201': 423, 'upload 202': 9} + t= 62s collector heap= 39.2 rss= 170.1 MiB queues={'loki': 18, 'prometheus': 0, 'tempo': 18} send_failed_total=0 TelemetryExportFailing=inactive http={'201': 547, 'upload 202': 12} + t= 77s collector heap= 43.6 rss= 170.1 MiB queues={'loki': 26, 'prometheus': 0, 'tempo': 26} send_failed_total=0 TelemetryExportFailing=inactive http={'201': 679, 'upload 202': 15} + t= 92s collector heap= 28.0 rss= 170.8 MiB queues={'loki': 33, 'prometheus': 0, 'tempo': 33} send_failed_total=0 TelemetryExportFailing=pending http={'201': 811, 'upload 202': 17} + t= 107s collector heap= 32.7 rss= 170.8 MiB queues={'loki': 40, 'prometheus': 0, 'tempo': 41} send_failed_total=0 TelemetryExportFailing=pending http={'201': 946, 'upload 202': 20} + t= 122s collector heap= 37.8 rss= 170.8 MiB queues={'loki': 48, 'prometheus': 0, 'tempo': 48} send_failed_total=0 TelemetryExportFailing=pending http={'201': 1079, 'upload 202': 23} + t= 137s collector heap= 42.6 rss= 170.8 MiB queues={'loki': 55, 'prometheus': 1, 'tempo': 55} send_failed_total=0 TelemetryExportFailing=pending http={'201': 1215, 'upload 202': 26} + t= 152s collector heap= 47.0 rss= 170.8 MiB queues={'loki': 63, 'prometheus': 0, 'tempo': 63} send_failed_total=0 TelemetryExportFailing=firing http={'201': 1346, 'upload 202': 29} + t= 167s collector heap= 32.3 rss= 170.8 MiB queues={'loki': 70, 'prometheus': 0, 'tempo': 70} send_failed_total=0 TelemetryExportFailing=firing http={'201': 1478, 'upload 202': 32} + t= 182s collector heap= 39.0 rss= 171.5 MiB queues={'loki': 78, 'prometheus': 0, 'tempo': 78} send_failed_total=0 TelemetryExportFailing=firing http={'201': 1613, 'upload 202': 35} + t= 197s collector heap= 45.3 rss= 175.0 MiB queues={'loki': 85, 'prometheus': 0, 'tempo': 85} send_failed_total=0 TelemetryExportFailing=firing http={'201': 1742, 'upload 202': 38} + upload 519f5171-09af-47e7-a0ea-65245c398527 made during the outage -> ready (business path unaffected) + during the outage: every business request succeeded {'201': 1742, 'upload 202': 38}; collector RSS max 175 MiB (heap max 47 MiB < 400 MiB limit); exporter queue max 85 of 200 batches; TelemetryExportFailing firing at t=152s +3. t=200s docker compose start tempo loki + t= 215s collector heap= 50.3 rss= 175.0 MiB queues={'loki': 93, 'prometheus': 0, 'tempo': 93} send_failed_total=0 TelemetryExportFailing=firing http={'201': 1896, 'upload 202': 41} + t= 230s collector heap= 51.7 rss= 175.6 MiB queues={'loki': 1, 'prometheus': 0, 'tempo': 0} send_failed_total=0 TelemetryExportFailing=firing http={'201': 2030, 'upload 202': 44} + t= 245s collector heap= 57.1 rss= 176.3 MiB queues={'loki': 0, 'prometheus': 0, 'tempo': 0} send_failed_total=0 TelemetryExportFailing=inactive http={'201': 2152, 'upload 202': 47} + queues drained and TelemetryExportFailing resolved at t=245s + upload a9b297a8-98b1-4fcb-a8a3-61b5c74473d3 from the middle of the outage: log (X-Request-Id 35573634eee641e9b9eee43ccbf50fc0) and trace ee597afda36071ba1c880f8d3b933b48 arrived after recovery (they waited in the collector queue); telemetry items dropped by exporters during the run: 0 +4. docker compose stop otel-collector for 60 s (the SDK cannot export at all) + API answered {'201': 538, 'upload 202': 12} while the collector was down (no errors); API replica RSS 147 -> 148 MiB (SDK queues are bounded: 2048 records per signal) +PASS: telemetry stores and the collector down -> business API unaffected, bounded collector memory and queues, delayed telemetry delivered after recovery, drops are counted diff --git a/evidence/telemetry-persistence.txt b/evidence/telemetry-persistence.txt new file mode 100644 index 0000000..6b2c923 --- /dev/null +++ b/evidence/telemetry-persistence.txt @@ -0,0 +1,6 @@ +python student-tests/telemetry_persistence.py +before: trace 1a2016e74cafe0c7717f50c9fe8fb2a8 (36 spans), log of X-Request-Id 86d2785fcf2044339046c8ad3b9b630d, HTTP requests counter at t-120s = 8177 +docker compose restart prometheus loki tempo grafana (same containers, volumes kept) +after: trace 1a2016e74cafe0c7717f50c9fe8fb2a8 — 36 spans; log found; counter at the same past moment = 8177 + Grafana: dashboard 'Messenger lab6: API, worker, очередь, SLO' still provisioned +PASS: Prometheus, Loki and Tempo keep their history in volumes across a restart diff --git a/evidence/test.txt b/evidence/test.txt new file mode 100644 index 0000000..c6f0ecd --- /dev/null +++ b/evidence/test.txt @@ -0,0 +1,2 @@ +python tests/smoke.py --base-url "http://127.0.0.1:8080" +PASS: lab6 public API scenario; infrastructure and grading evidence remain separate. diff --git a/infra/grafana/dashboards/messenger.json b/infra/grafana/dashboards/messenger.json new file mode 100644 index 0000000..b80b49c --- /dev/null +++ b/infra/grafana/dashboards/messenger.json @@ -0,0 +1,1582 @@ +{ + "uid": "messenger-lab6", + "title": "Messenger lab6: API, worker, очередь, SLO", + "tags": [ + "lab6", + "messenger" + ], + "timezone": "browser", + "schemaVersion": 41, + "version": 1, + "editable": true, + "refresh": "10s", + "time": { + "from": "now-30m", + "to": "now" + }, + "templating": { + "list": [] + }, + "annotations": { + "list": [] + }, + "panels": [ + { + "type": "row", + "title": "SLO и alerts (окно SLO — 1 час)", + "id": 1, + "collapsed": false, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 0 + }, + "panels": [] + }, + { + "type": "stat", + "title": "SLO-1 доступность API, 1 ч (цель ≥ 99%)", + "description": "Доля ответов клиентам без 5xx на входе HAProxy за последний час. Источник: haproxy_frontend_http_responses_total.", + "id": 2, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 5, + "w": 6, + "x": 0, + "y": 1 + }, + "fieldConfig": { + "defaults": { + "unit": "percentunit", + "decimals": 3, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "red", + "value": null + }, + { + "color": "green", + "value": 0.99 + } + ] + } + }, + "overrides": [] + }, + "options": { + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "colorMode": "background", + "graphMode": "area", + "textMode": "auto" + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "messenger:edge_availability:ratio1h", + "instant": false + } + ] + }, + { + "type": "stat", + "title": "SLO-2 p95 задержки API, 5 мин (цель < 0.5 с)", + "description": "p95 из buckets гистограммы http.server.request.duration всех реплик (sum by le), без /health.", + "id": 3, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 5, + "w": 6, + "x": 6, + "y": 1 + }, + "fieldConfig": { + "defaults": { + "unit": "s", + "decimals": 3, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 0.5 + } + ] + } + }, + "overrides": [] + }, + "options": { + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "colorMode": "background", + "graphMode": "area", + "textMode": "auto" + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "messenger:http_latency_p95:5m", + "instant": false + } + ] + }, + { + "type": "stat", + "title": "SLO-3 вложения ready < 30 с, 1 ч (цель ≥ 95%)", + "description": "Доля вложений, ставших ready быстрее 30 с от принятия загрузки (bucket le=30 / count).", + "id": 4, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 5, + "w": 6, + "x": 12, + "y": 1 + }, + "fieldConfig": { + "defaults": { + "unit": "percentunit", + "decimals": 3, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "red", + "value": null + }, + { + "color": "green", + "value": 0.95 + } + ] + } + }, + "overrides": [] + }, + "options": { + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "colorMode": "background", + "graphMode": "area", + "textMode": "auto" + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "messenger:time_to_ready_under_30s:ratio1h", + "instant": false + } + ] + }, + { + "type": "state-timeline", + "title": "Alerts: pending / firing", + "description": "Состояние alert rules Prometheus (infra/prometheus/rules/alerts.yml). 1 = alert в этом состоянии.", + "id": 5, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 5, + "w": 6, + "x": 18, + "y": 1 + }, + "fieldConfig": { + "defaults": { + "unit": "none", + "color": { + "mode": "thresholds" + }, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "transparent", + "value": null + }, + { + "color": "red", + "value": 1 + } + ] + } + }, + "overrides": [] + }, + "options": { + "showValue": "never", + "mergeValues": true, + "rowHeight": 0.8 + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "max by (alertname, alertstate) (ALERTS)", + "legendFormat": "{{alertname}} {{alertstate}}" + } + ] + }, + { + "type": "row", + "title": "API: трафик, ошибки, задержка", + "id": 6, + "collapsed": false, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 6 + }, + "panels": [] + }, + { + "type": "timeseries", + "title": "RPS по маршрутам", + "description": "Бизнес-запросы в секунду по маршруту-шаблону (без /health). Единица: запросов/с.", + "id": 7, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 0, + "y": 7 + }, + "fieldConfig": { + "defaults": { + "unit": "reqps", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum by (http_route) (rate(http_server_request_duration_seconds_count{job=\"messenger-api\"}[1m]))", + "legendFormat": "{{http_route}}" + } + ] + }, + { + "type": "timeseries", + "title": "Ошибки: вход HAProxy и приложение (доля)", + "description": "Числитель — 5xx, знаменатель — все ответы. 4xx (неверный пароль, чужой чат) — не отказ сервиса. Если 5xx есть только на входе — HAProxy сам отвечает 503: нет готовых реплик.", + "id": 8, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 8, + "y": 7 + }, + "fieldConfig": { + "defaults": { + "unit": "percentunit", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false, + "thresholdsStyle": { + "mode": "line+area" + } + }, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 0.05 + } + ] + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "messenger:edge_error_ratio:rate2m", + "legendFormat": "5xx на входе (HAProxy, SLI)" + }, + { + "refId": "B", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum(rate(http_server_request_duration_seconds_count{job=\"messenger-api\",http_response_status_code=~\"5..\"}[2m])) / sum(rate(http_server_request_duration_seconds_count{job=\"messenger-api\"}[2m]))", + "legendFormat": "5xx приложения" + }, + { + "refId": "C", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum(rate(http_server_request_duration_seconds_count{job=\"messenger-api\",http_response_status_code=~\"4..\"}[2m])) / sum(rate(http_server_request_duration_seconds_count{job=\"messenger-api\"}[2m]))", + "legendFormat": "4xx приложения (ошибки клиента)" + } + ] + }, + { + "type": "timeseries", + "title": "Задержка API p50 / p95 / p99", + "description": "Перцентили из buckets гистограммы всех реплик (sum by le), а не среднее и не среднее p95 реплик. Единица: секунды.", + "id": 9, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 16, + "y": 7 + }, + "fieldConfig": { + "defaults": { + "unit": "s", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false, + "thresholdsStyle": { + "mode": "line+area" + } + }, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 0.5 + } + ] + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "histogram_quantile(0.50, sum by (le) (rate(http_server_request_duration_seconds_bucket{job=\"messenger-api\"}[5m])))", + "legendFormat": "p50" + }, + { + "refId": "B", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "histogram_quantile(0.95, sum by (le) (rate(http_server_request_duration_seconds_bucket{job=\"messenger-api\"}[5m])))", + "legendFormat": "p95" + }, + { + "refId": "C", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "histogram_quantile(0.99, sum by (le) (rate(http_server_request_duration_seconds_bucket{job=\"messenger-api\"}[5m])))", + "legendFormat": "p99" + } + ] + }, + { + "type": "timeseries", + "title": "p95 по маршрутам", + "description": "Какой обработчик медленный. Секунды.", + "id": 10, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 0, + "y": 15 + }, + "fieldConfig": { + "defaults": { + "unit": "s", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "histogram_quantile(0.95, sum by (le, http_route) (rate(http_server_request_duration_seconds_bucket{job=\"messenger-api\"}[5m])))", + "legendFormat": "{{http_route}}" + } + ] + }, + { + "type": "timeseries", + "title": "Ответы клиентам по классам (HAProxy) и готовые реплики", + "description": "Ответов/с по классу кода на входе и число реплик, прошедших /health/ready.", + "id": 11, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 8, + "y": 15 + }, + "fieldConfig": { + "defaults": { + "unit": "short", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum by (code) (rate(haproxy_frontend_http_responses_total{proxy=\"api_in\"}[1m]))", + "legendFormat": "{{code}}" + }, + { + "refId": "B", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "haproxy_backend_active_servers{proxy=\"api\"}", + "legendFormat": "готовых реплик API" + } + ] + }, + { + "type": "timeseries", + "title": "Запросы в обработке", + "description": "Одновременно выполняемые запросы на реплику.", + "id": 12, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 16, + "y": 15 + }, + "fieldConfig": { + "defaults": { + "unit": "short", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum by (instance) (http_server_active_requests{job=\"messenger-api\"})", + "legendFormat": "{{instance}}" + } + ] + }, + { + "type": "row", + "title": "Очередь заданий и worker", + "id": 13, + "collapsed": false, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 23 + }, + "panels": [] + }, + { + "type": "timeseries", + "title": "Глубина очереди (backlog)", + "description": "Сколько заданий ждёт (ready), в паузе перед повтором (delayed), в работе (processing). max по репликам API: обе считают одно и то же из PostgreSQL. Единица: задания.", + "id": 14, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 0, + "y": 24 + }, + "fieldConfig": { + "defaults": { + "unit": "short", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "max by (state) (messenger_queue_depth{job=\"messenger-api\"})", + "legendFormat": "задания: {{state}}" + }, + { + "refId": "B", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "max(messenger_outbox_pending{job=\"messenger-api\"})", + "legendFormat": "outbox: ещё не в брокере" + } + ] + }, + { + "type": "timeseries", + "title": "Возраст старейшего задания (lag)", + "description": "Сколько ждёт самое старое задание, которое уже можно обрабатывать. Порог alert QueueLagHigh — 60 с. Это ожидание, а не время обработки.", + "id": 15, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 8, + "y": 24 + }, + "fieldConfig": { + "defaults": { + "unit": "s", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false, + "thresholdsStyle": { + "mode": "line+area" + } + }, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 60 + } + ] + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "max(messenger_queue_oldest_age_seconds{job=\"messenger-api\"})", + "legendFormat": "задание ждёт worker" + }, + { + "refId": "B", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "max(messenger_outbox_oldest_age_seconds{job=\"messenger-api\"})", + "legendFormat": "строка outbox ждёт брокер" + } + ] + }, + { + "type": "timeseries", + "title": "Задания по исходу", + "description": "Доставки, обработанные worker, в секунду: ready, retry, failed, skipped (дубль), lost, db_unavailable, invalid.", + "id": 16, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 16, + "y": 24 + }, + "fieldConfig": { + "defaults": { + "unit": "ops", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum by (outcome) (rate(messenger_jobs_processed_total[1m]))", + "legendFormat": "{{outcome}}" + } + ] + }, + { + "type": "timeseries", + "title": "Обработка задания p50 / p95 / p99 (worker)", + "description": "Длительность успешной попытки: claim -> S3 -> картинка -> S3 -> COMMIT. Секунды.", + "id": 17, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 0, + "y": 32 + }, + "fieldConfig": { + "defaults": { + "unit": "s", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "histogram_quantile(0.50, sum by (le) (rate(messenger_job_duration_seconds_bucket{outcome=\"ready\"}[5m])))", + "legendFormat": "p50" + }, + { + "refId": "B", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "histogram_quantile(0.95, sum by (le) (rate(messenger_job_duration_seconds_bucket{outcome=\"ready\"}[5m])))", + "legendFormat": "p95" + }, + { + "refId": "C", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "histogram_quantile(0.99, sum by (le) (rate(messenger_job_duration_seconds_bucket{outcome=\"ready\"}[5m])))", + "legendFormat": "p99" + } + ] + }, + { + "type": "timeseries", + "title": "Время до ready p50 / p95 / p99", + "description": "От COMMIT загрузки (202) до COMMIT ready: ожидание в очереди + все попытки. Секунды.", + "id": 18, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 8, + "y": 32 + }, + "fieldConfig": { + "defaults": { + "unit": "s", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false, + "thresholdsStyle": { + "mode": "line+area" + } + }, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 30 + } + ] + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "histogram_quantile(0.50, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket[5m])))", + "legendFormat": "p50" + }, + { + "refId": "B", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "histogram_quantile(0.95, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket[5m])))", + "legendFormat": "p95" + }, + { + "refId": "C", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "histogram_quantile(0.99, sum by (le) (rate(messenger_attachment_time_to_ready_seconds_bucket[5m])))", + "legendFormat": "p99" + } + ] + }, + { + "type": "timeseries", + "title": "Насыщение worker", + "description": "Доля занятых слотов worker (WORKER_CONCURRENCY на процесс). 100% долго — не хватает мощности.", + "id": 19, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 16, + "y": 32 + }, + "fieldConfig": { + "defaults": { + "unit": "percentunit", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false, + "thresholdsStyle": { + "mode": "line+area" + } + }, + "min": 0, + "max": 1, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 0.9 + } + ] + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum(messenger_worker_busy) / sum(messenger_worker_capacity)", + "legendFormat": "занято / всего" + } + ] + }, + { + "type": "row", + "title": "Ресурсы: пул БД, CPU, память", + "id": 20, + "collapsed": false, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 40 + }, + "panels": [] + }, + { + "type": "timeseries", + "title": "Пул соединений с БД", + "description": "used/idle/максимум и запросы, ждущие соединение (сумма по репликам). Ожидающие > 0 — пул исчерпан или БД отвечает медленно.", + "id": 21, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 0, + "y": 41 + }, + "fieldConfig": { + "defaults": { + "unit": "short", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum by (db_client_connection_pool_name, db_client_connection_state) (db_client_connection_count)", + "legendFormat": "{{db_client_connection_pool_name}} {{db_client_connection_state}}" + }, + { + "refId": "B", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum by (db_client_connection_pool_name) (db_client_connection_pending_requests)", + "legendFormat": "{{db_client_connection_pool_name}} ждут соединение" + }, + { + "refId": "C", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum by (db_client_connection_pool_name) (db_client_connection_max)", + "legendFormat": "{{db_client_connection_pool_name}} максимум" + } + ] + }, + { + "type": "timeseries", + "title": "CPU процессов (ядер)", + "description": "Секунды CPU в секунду = занятых ядер. Без дочерних процессов обработки картинок worker.", + "id": 22, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 8, + "y": 41 + }, + "fieldConfig": { + "defaults": { + "unit": "short", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum by (job, instance) (rate(process_cpu_time_seconds_total{job=~\"messenger-.*\"}[1m]))", + "legendFormat": "{{job}} {{instance}}" + }, + { + "refId": "B", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "rate(otelcol_process_cpu_seconds_total[1m])", + "legendFormat": "otel-collector" + } + ] + }, + { + "type": "timeseries", + "title": "Память процессов (RSS)", + "description": "Резидентная память (RSS). У Collector memory_limiter ограничивает кучу (400 МиБ), лимит контейнера 512 МиБ.", + "id": 23, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 16, + "y": 41 + }, + "fieldConfig": { + "defaults": { + "unit": "bytes", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "process_memory_usage_bytes{job=~\"messenger-.*\"}", + "legendFormat": "{{job}} {{instance}}" + }, + { + "refId": "B", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "otelcol_process_memory_rss_bytes", + "legendFormat": "otel-collector RSS" + }, + { + "refId": "C", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "otelcol_process_runtime_heap_alloc_bytes", + "legendFormat": "otel-collector куча" + } + ] + }, + { + "type": "row", + "title": "Конвейер телеметрии (OTel Collector)", + "id": 24, + "collapsed": false, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 49 + }, + "panels": [] + }, + { + "type": "timeseries", + "title": "Принято / отправлено / потеряно (в секунду)", + "description": "Если хранилище недоступно: отправлено падает до 0, растёт «не отправлено» (после 5 минут повторов) и очередь exporter.", + "id": 25, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 12, + "x": 0, + "y": 50 + }, + "fieldConfig": { + "defaults": { + "unit": "short", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum(rate(otelcol_receiver_accepted_spans_total[1m]))", + "legendFormat": "spans принято" + }, + { + "refId": "B", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum(rate(otelcol_exporter_sent_spans_total[1m]))", + "legendFormat": "spans отправлено" + }, + { + "refId": "C", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum(rate(otelcol_exporter_send_failed_spans_total[1m]))", + "legendFormat": "spans не отправлено" + }, + { + "refId": "D", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum(rate(otelcol_receiver_accepted_log_records_total[1m]))", + "legendFormat": "логи принято" + }, + { + "refId": "E", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum(rate(otelcol_exporter_sent_log_records_total[1m]))", + "legendFormat": "логи отправлено" + }, + { + "refId": "F", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum(rate(otelcol_exporter_send_failed_log_records_total[1m]))", + "legendFormat": "логи не отправлено" + }, + { + "refId": "G", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum(rate(otelcol_exporter_sent_metric_points_total[1m]))", + "legendFormat": "точки метрик отправлено" + }, + { + "refId": "H", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum(rate(otelcol_exporter_send_failed_metric_points_total[1m]))", + "legendFormat": "точки метрик не отправлено" + } + ] + }, + { + "type": "timeseries", + "title": "Очереди exporter (пачки)", + "description": "Очередь ограничена ёмкостью: при недоступном хранилище она заполняется, но не растёт бесконечно.", + "id": 26, + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "gridPos": { + "h": 8, + "w": 12, + "x": 12, + "y": 50 + }, + "fieldConfig": { + "defaults": { + "unit": "short", + "custom": { + "lineWidth": 2, + "fillOpacity": 10, + "showPoints": "never", + "spanNulls": false + } + }, + "overrides": [] + }, + "options": { + "legend": { + "displayMode": "table", + "placement": "bottom", + "calcs": [ + "lastNotNull", + "max" + ] + }, + "tooltip": { + "mode": "multi" + } + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "sum by (exporter) (otelcol_exporter_queue_size)", + "legendFormat": "{{exporter}} в очереди" + }, + { + "refId": "B", + "datasource": { + "type": "prometheus", + "uid": "prometheus" + }, + "expr": "max(otelcol_exporter_queue_capacity)", + "legendFormat": "ёмкость" + } + ] + }, + { + "type": "row", + "title": "Логи и трассы", + "id": 27, + "collapsed": false, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 58 + }, + "panels": [] + }, + { + "type": "logs", + "title": "Логи API и worker (предупреждения и ошибки)", + "id": 28, + "datasource": { + "type": "loki", + "uid": "loki" + }, + "gridPos": { + "h": 10, + "w": 12, + "x": 0, + "y": 59 + }, + "description": "Структурные логи: event, severity, trace_id/span_id. Клик по записи -> кнопка Trace открывает трассу в Tempo.", + "options": { + "showTime": true, + "wrapLogMessage": true, + "enableLogDetails": true, + "sortOrder": "Descending", + "dedupStrategy": "none" + }, + "targets": [ + { + "refId": "A", + "datasource": { + "type": "loki", + "uid": "loki" + }, + "expr": "{service_name=~\"messenger-api|messenger-worker\"} | severity_text=~\"WARN.*|ERROR|CRITICAL\"", + "queryType": "range" + } + ] + }, + { + "type": "table", + "title": "Трассы загрузок (последние)", + "id": 29, + "datasource": { + "type": "tempo", + "uid": "tempo" + }, + "gridPos": { + "h": 10, + "w": 12, + "x": 12, + "y": 59 + }, + "description": "TraceQL: server span загрузки с attachment_id. Клик по trace ID — вся цепочка upload -> publish -> consume -> S3/DB.", + "targets": [ + { + "refId": "A", + "datasource": { + "type": "tempo", + "uid": "tempo" + }, + "queryType": "traceql", + "limit": 20, + "tableType": "traces", + "query": "{ kind = server && span.messenger.attachment.id != \"\" }" + } + ] + } + ], + "description": "Импортируется автоматически (infra/grafana/provisioning/dashboards). Запросы и единицы — в REPORT.md." +} \ No newline at end of file diff --git a/infra/grafana/provisioning/dashboards/dashboards.yaml b/infra/grafana/provisioning/dashboards/dashboards.yaml new file mode 100644 index 0000000..1f663f3 --- /dev/null +++ b/infra/grafana/provisioning/dashboards/dashboards.yaml @@ -0,0 +1,15 @@ +# Dashboard'ы импортируются из файлов infra/grafana/dashboards/*.json (смонтированы в контейнер). +# allowUiUpdates: false — источник истины файл в Git; правки в интерфейсе не сохраняются в него. +apiVersion: 1 + +providers: + - name: messenger + orgId: 1 + folder: Messenger + type: file + disableDeletion: true + allowUiUpdates: false + updateIntervalSeconds: 30 + options: + path: /var/lib/grafana/dashboards + foldersFromFilesStructure: false diff --git a/infra/grafana/provisioning/datasources/datasources.yaml b/infra/grafana/provisioning/datasources/datasources.yaml new file mode 100644 index 0000000..660eded --- /dev/null +++ b/infra/grafana/provisioning/datasources/datasources.yaml @@ -0,0 +1,62 @@ +# Источники данных Grafana (импортируются при старте, в интерфейсе их нельзя изменить — readOnly). +# Grafana сама ничего не хранит: она отправляет запросы в три хранилища. +# Внутри: «$$» — это буквальный «$» (Grafana подставляет переменные окружения в $NAME). +apiVersion: 1 + +datasources: + - name: Prometheus + uid: prometheus + type: prometheus + access: proxy + url: http://prometheus:9090 + isDefault: true + editable: false + jsonData: + httpMethod: POST + prometheusType: Prometheus + timeInterval: 15s + + - name: Loki + uid: loki + type: loki + access: proxy + url: http://loki:3100 + editable: false + jsonData: + maxLines: 1000 + # Из записи лога — переход к трассе: trace_id хранится в structured metadata записи. + derivedFields: + - name: trace_id + matcherType: label + matcherRegex: trace_id + datasourceUid: tempo + url: "$${__value.raw}" + urlDisplayLabel: "Открыть трассу" + + - name: Tempo + uid: tempo + type: tempo + access: proxy + url: http://tempo:3200 + editable: false + jsonData: + nodeGraph: + enabled: true + search: + hide: false + # Из span — переход к логам этой трассы в Loki (по trace_id, ±5 минут от span). + tracesToLogsV2: + datasourceUid: loki + spanStartTimeShift: "-5m" + spanEndTimeShift: "5m" + filterByTraceID: false + customQuery: true + query: '{service_name=~"messenger-api|messenger-worker"} | trace_id="$${__trace.traceId}"' + # Из span — к метрикам того же сервиса в Prometheus. + tracesToMetrics: + datasourceUid: prometheus + spanStartTimeShift: "-5m" + spanEndTimeShift: "5m" + queries: + - name: "RPS сервиса" + query: 'sum(rate(http_server_request_duration_seconds_count{job="messenger-api"}[1m]))' diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 0000000..961ffd3 --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -0,0 +1,95 @@ +# 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 } + # С lab6: метрики балансировщика для Prometheus (встроенный экспортёр HAProxy). Это взгляд + # клиента: ответы 5xx, которые HAProxy вернул сам (нет готовой реплики), тоже считаются. + # По ним считается SLI доступности и alert HighErrorRate (infra/prometheus/rules/alerts.yml). + http-request use-service prometheus-exporter if { path /metrics } + stats enable + stats uri /stats + stats refresh 2s diff --git a/infra/loki/loki.yaml b/infra/loki/loki.yaml new file mode 100644 index 0000000..82107b4 --- /dev/null +++ b/infra/loki/loki.yaml @@ -0,0 +1,69 @@ +# Loki 3.5.8 стенда lab6 — хранилище ЛОГОВ (один процесс, данные на диске в volume lokidata). +# +# Логи приходят от Collector по OTLP (/otlp/v1/logs). Labels потока (индекс) — только ресурсные +# атрибуты с маленьким числом значений: service_name, service_instance_id, deployment_environment_name. +# Остальное (event, severity, trace_id, span_id, request_id, attachment_id…) хранится как structured +# metadata записи: по нему можно фильтровать (| trace_id="..."), но в индекс оно не попадает, +# поэтому ID не раздувают число потоков. +auth_enabled: false + +server: + http_listen_port: 3100 + grpc_listen_port: 9096 + log_level: warn + +common: + instance_addr: 127.0.0.1 + path_prefix: /loki + replication_factor: 1 + ring: + kvstore: + store: inmemory + storage: + filesystem: + chunks_directory: /loki/chunks + rules_directory: /loki/rules + +schema_config: + configs: + - from: "2024-01-01" + store: tsdb + object_store: filesystem + schema: v13 + index: + prefix: index_ + period: 24h + +limits_config: + allow_structured_metadata: true # нужно для OTLP-логов (trace_id, span_id, event…) + retention_period: 168h # 7 дней + ingestion_rate_mb: 8 + ingestion_burst_size_mb: 16 + max_query_lookback: 168h + otlp_config: + resource_attributes: + ignore_defaults: true # только явный короткий список labels ниже + attributes_config: + - action: index_label + attributes: [service.name, service.instance.id, deployment.environment.name] + +ingester: + # Журнал (WAL) в volume: принятые, но ещё не записанные в chunks логи переживают перезапуск Loki. + wal: + enabled: true + dir: /loki/wal + flush_on_shutdown: true # при остановке записать chunks на диск + +compactor: + working_directory: /loki/compactor + retention_enabled: true + delete_request_store: filesystem + +ruler: + storage: + type: local + local: + directory: /loki/rules + +analytics: + reporting_enabled: false diff --git a/infra/otel/collector.yaml b/infra/otel/collector.yaml new file mode 100644 index 0000000..826564d --- /dev/null +++ b/infra/otel/collector.yaml @@ -0,0 +1,109 @@ +# OpenTelemetry Collector (otelcol-contrib 0.140.1) стенда lab6. +# +# API и worker отправляют сюда по OTLP/HTTP (:4318) три сигнала. Collector их не хранит: +# он принимает (receivers), обрабатывает (processors) и отправляет в хранилища (exporters): +# traces -> Tempo (OTLP/HTTP, tempo:4318) +# logs -> Loki (родной OTLP-приём Loki 3, loki:3100/otlp) +# metrics -> Prometheus (родной OTLP-приём Prometheus 3, prometheus:9090/api/v1/otlp) +# Порт 4318 слушается только во внутренней сети telemetry: наружу Collector не опубликован. +# +# Ограничение памяти и буферов (уровень 4, «остановка telemetry-хранилища не ломает сообщения +# и не вызывает бесконечный рост RAM»): +# - memory_limiter первым в каждом pipeline: когда куча Go доходит до 400 МиБ (лимит контейнера +# 512 МиБ), Collector перестаёт принимать данные (клиенту — ошибка, SDK отбрасывает у себя), а не +# растёт дальше. Ограничивается именно куча: в RSS процесса ещё ~150 МиБ — сам бинарник contrib; +# - batch собирает данные пачками (меньше запросов к хранилищам); +# - у каждого exporter своя очередь в памяти: не больше QUEUE пачек; повторы с паузой 1…30 с, +# не дольше 5 минут, потом пачка отбрасывается. Переполненная очередь тоже отбрасывает новые пачки. +# Потери считаются собственными метриками Collector (otelcol_exporter_send_failed_*, +# otelcol_exporter_enqueue_failed_*, otelcol_exporter_queue_size), их собирает Prometheus. +# Приложение от Collector не зависит: SDK отправляет в фоне и при ошибке отбрасывает (telemetry.py). + +extensions: + health_check: + endpoint: 0.0.0.0:13133 + +receivers: + otlp: + protocols: + http: + endpoint: 0.0.0.0:4318 + max_request_body_size: 8388608 # 8 МиБ на запрос: больше не принимаем + +processors: + memory_limiter: + check_interval: 1s + limit_mib: 400 + spike_limit_mib: 80 + batch: + send_batch_size: 1024 + send_batch_max_size: 2048 + timeout: 2s + # Страховка от утечки чувствительных данных: даже если какая-то инструментация запишет + # query-строку, полный URL или заголовки авторизации — они удаляются до хранилищ. + attributes/scrub: + actions: + - {key: url.query, action: delete} + - {key: url.full, action: delete} + - {key: http.url, action: delete} + - {key: http.target, action: delete} + - {key: http.request.header.authorization, action: delete} + - {key: http.request.header.cookie, action: delete} + - {pattern: ^db\.query\.parameter\..*, action: delete} + +exporters: + otlphttp/tempo: + endpoint: http://tempo:4318 + compression: gzip + timeout: 10s + sending_queue: &queue + enabled: true + num_consumers: 2 + queue_size: 200 # пачек; при batch до 2048 записей — ограниченный объём + retry_on_failure: &retry + enabled: true + initial_interval: 1s + max_interval: 30s + max_elapsed_time: 300s + otlphttp/loki: + endpoint: http://loki:3100/otlp + compression: gzip + timeout: 10s + sending_queue: *queue + retry_on_failure: *retry + otlphttp/prometheus: + # Prometheus принимает OTLP-метрики по пути /api/v1/otlp/v1/metrics (флаг --web.enable-otlp-receiver). + metrics_endpoint: http://prometheus:9090/api/v1/otlp/v1/metrics + compression: gzip + timeout: 10s + sending_queue: *queue + retry_on_failure: *retry + +service: + extensions: [health_check] + pipelines: + traces: + receivers: [otlp] + processors: [memory_limiter, attributes/scrub, batch] + exporters: [otlphttp/tempo] + logs: + receivers: [otlp] + processors: [memory_limiter, attributes/scrub, batch] + exporters: [otlphttp/loki] + metrics: + receivers: [otlp] + processors: [memory_limiter, batch] + exporters: [otlphttp/prometheus] + telemetry: + logs: + level: info + # Собственные метрики Collector (принято/отправлено/отброшено, размер очередей) на :8888, + # их забирает Prometheus (scrape job otel-collector). + metrics: + level: detailed + readers: + - pull: + exporter: + prometheus: + host: 0.0.0.0 + port: 8888 diff --git a/infra/prometheus/prometheus.yml b/infra/prometheus/prometheus.yml new file mode 100644 index 0000000..d7d7691 --- /dev/null +++ b/infra/prometheus/prometheus.yml @@ -0,0 +1,39 @@ +# Prometheus 3.7.3 стенда lab6 — хранилище МЕТРИК. +# +# Метрики приложения приходят push-ом по OTLP от Collector (флаг --web.enable-otlp-receiver +# в compose.yaml). Имена переводятся в стиль Prometheus: точки -> «_», единица -> суффикс +# (http.server.request.duration [s] -> http_server_request_duration_seconds_bucket/_sum/_count), +# service.name -> label job, service.instance.id -> label instance. +# Сам Prometheus опрашивает (scrape) только собственные метрики Collector (:8888) и балансировщик +# (lb:8404/metrics — ответы клиентам, включая 503 самого HAProxy, когда нет готовой реплики). +# Здесь же вычисляются alert rules (rules/alerts.yml): состояние pending/firing/resolved видно +# на http://127.0.0.1:9090/alerts и в Grafana. Отправки наружу (Alertmanager) нет — не требуется. + +global: + scrape_interval: 15s + evaluation_interval: 15s + +rule_files: + - /etc/prometheus/rules/*.yml + +scrape_configs: + - job_name: otel-collector + static_configs: + - targets: ["otel-collector:8888"] + - job_name: haproxy + static_configs: + - targets: ["lb:8404"] + - job_name: prometheus + static_configs: + - targets: ["127.0.0.1:9090"] + +otlp: + # Ресурсные атрибуты, которые станут labels всех метрик (остальные — в серии target_info). + promote_resource_attributes: + - service.version + - deployment.environment.name + +storage: + tsdb: + # Пачки OTLP от разных процессов приходят не строго по времени: принимаем опоздания до 30 мин. + out_of_order_time_window: 30m diff --git a/infra/prometheus/rules/alerts.yml b/infra/prometheus/rules/alerts.yml new file mode 100644 index 0000000..9ff8380 --- /dev/null +++ b/infra/prometheus/rules/alerts.yml @@ -0,0 +1,96 @@ +# Alert rules стенда lab6 (вычисляет Prometheus раз в 15 с). Доставки наружу нет: состояние +# inactive -> pending -> firing -> (resolved) видно на http://127.0.0.1:9090/alerts, в Grafana +# (Alerting -> Alert rules, источник Prometheus) и через API /api/v1/alerts. +# Что делать при срабатывании — infra/prometheus/runbooks.md. +# +# SLI/SLO (окно — скользящий 1 час, учебный стенд; в эксплуатации было бы 28–30 дней): +# SLO-1 доступность API: >= 99% ответов клиентам (вход HAProxy, без /health) — не 5xx; +# SLO-2 задержка API: p95 бизнес-запросов (гистограмма приложения) < 0.5 с; +# SLO-3 обработка: 95% вложений готовы (ready) быстрее 30 с от принятия загрузки. +# Recording rules ниже считают эти SLI, dashboard показывает их рядом с целями. + +groups: + - name: messenger-sli + interval: 15s + rules: + # Доля 5xx на входе: числитель — ответы 5xx клиентам (из приложения и от самого HAProxy), + # знаменатель — все ответы фронтенда api_in. Неверный пароль клиента (401) — не ошибка сервиса. + - record: messenger:edge_error_ratio:rate2m + expr: | + sum(rate(haproxy_frontend_http_responses_total{proxy="api_in",code="5xx"}[2m])) + / + sum(rate(haproxy_frontend_http_responses_total{proxy="api_in"}[2m])) + - record: messenger:edge_availability:ratio1h + expr: | + 1 - ( + sum(increase(haproxy_frontend_http_responses_total{proxy="api_in",code="5xx"}[1h])) + / + sum(increase(haproxy_frontend_http_responses_total{proxy="api_in"}[1h])) + ) + # p95 по buckets ВСЕХ реплик (сумма по le), а не среднее p95 реплик. + - record: messenger:http_latency_p95:5m + expr: | + histogram_quantile(0.95, + sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api"}[5m]))) + - record: messenger:time_to_ready_under_30s:ratio1h + expr: | + sum(increase(messenger_attachment_time_to_ready_seconds_bucket{le=~"30(\\.0)?"}[1h])) + / + sum(increase(messenger_attachment_time_to_ready_seconds_count[1h])) + + - name: messenger-alerts + rules: + - alert: HighErrorRate + # Больше 5% ответов клиентам — 5xx за последние 2 минуты, и это держится 1 минуту. + # При трафике меньше 0.2 запроса/с alert не считается: 1 ошибка из 3 запросов — не инцидент. + expr: | + messenger:edge_error_ratio:rate2m > 0.05 + and on() sum(rate(haproxy_frontend_http_responses_total{proxy="api_in"}[2m])) > 0.2 + for: 1m + labels: + severity: page + slo: availability + annotations: + summary: "Доля 5xx на входе API {{ $value | humanizePercentage }} (порог 5%)" + description: >- + Клиенты получают 5xx. Сравните панель «Ошибки: вход HAProxy и приложение»: если 5xx отдаёт + сам HAProxy (у приложения ошибок нет) — нет готовых реплик (обычно недоступна БД или S3); + если 5xx отдаёт приложение — ищите trace с ошибкой и лог по X-Request-Id. + runbook: infra/prometheus/runbooks.md#higherrorrate + + - alert: QueueLagHigh + # Самое старое задание, которое уже можно обрабатывать, ждёт worker дольше 60 с, 1 минуту подряд. + # Это отставание очереди (lag), а не длительность обработки: worker не берёт задания. + expr: max by (queue) (messenger_queue_oldest_age_seconds{job="messenger-api"}) > 60 + for: 1m + labels: + severity: page + slo: processing + annotations: + summary: "Задание ждёт обработки {{ $value | humanizeDuration }} (очередь {{ $labels.queue }})" + description: >- + Возраст старейшего задания растёт: worker не забирает задания. Проверьте панели + «Worker: занято/всего» и «Задания по исходу»: 0 доставок — worker остановлен или не + подключён к брокеру; заняты все слоты — не хватает мощности. + runbook: infra/prometheus/runbooks.md#queuelaghigh + + - alert: TelemetryExportFailing + # Collector не может отправить данные в хранилище (Tempo, Loki или Prometheus): ошибки отправки + # или больше 20 пачек в очереди exporter, 1 минуту подряд. + # Бизнес-функции не затронуты, но часть телеметрии теряется после исчерпания повторов. + expr: | + sum by (exporter) ( + rate(otelcol_exporter_send_failed_spans_total[2m]) + or rate(otelcol_exporter_send_failed_log_records_total[2m]) + or rate(otelcol_exporter_send_failed_metric_points_total[2m]) + ) > 0 + or sum by (exporter) (otelcol_exporter_queue_size) > 20 + for: 1m + labels: + severity: ticket + annotations: + summary: "Collector не может отправить телеметрию: {{ $labels.exporter }}" + description: >- + Хранилище телеметрии недоступно или перегружено. Очередь exporter ограничена + (200 пачек), после 5 минут повторов пачки отбрасываются — потери видны на панели Collector. + runbook: infra/prometheus/runbooks.md#telemetryexportfailing diff --git a/infra/prometheus/runbooks.md b/infra/prometheus/runbooks.md new file mode 100644 index 0000000..91f2498 --- /dev/null +++ b/infra/prometheus/runbooks.md @@ -0,0 +1,56 @@ +# Runbooks alerts (lab6) + +Alerts вычисляет Prometheus (`infra/prometheus/rules/alerts.yml`). Состояние: http://127.0.0.1:9090/alerts, +`make alerts`, панель «Alerts: pending / firing» в Grafana (http://127.0.0.1:3000, dashboard +«Messenger lab6»). Доставки наружу нет. Все шаги ниже — только по сохранённым наблюдениям. + +## HighErrorRate + +**Условие.** Доля ответов 5xx на входе HAProxy за 2 минуты > 5% и держится 1 минуту +(`messenger:edge_error_ratio:rate2m > 0.05`, трафик > 0.2 запроса/с). Это SLI доступности (SLO-1: ≥ 99% за час). + +**Шаги.** +1. Панель «Ошибки: вход HAProxy и приложение». + - 5xx есть у приложения → ошибки отдаёт код API. Переходите к шагу 2. + - 5xx только на входе, у приложения запросов почти нет, «готовых реплик API» = 0 → HAProxy сам + отвечает 503: ни одна реплика не проходит `/health/ready`. Причина — PostgreSQL или S3. + Логи: `{service_name="messenger-api"} | event="http.request" | http_route="/health/ready"`. +2. Какой маршрут: панель «p95 по маршрутам» и «RPS по маршрутам». +3. Трасса ошибки: в Loki `{service_name="messenger-api"} | severity_text="WARNING" | event="http.request"` + → запись с кодом 5xx → кнопка «Открыть трассу» (или по `request_id` из ответа клиента `X-Request-Id`). +4. В трассе сравните длительность server span и SQL-спанов: + - SQL-спан длинный (≈ 5 с, statement_timeout) со статусом ERROR → **медленная БД** (блокировка, + долгая транзакция, перегрузка). Пул соединений: растёт `used`/`ждут соединение`. + Проверка в БД: `make explain`, блокировки — `SELECT * FROM pg_locks WHERE NOT granted`. + - SQL-спаны короткие, а server span длинный → медленный **код обработчика**, БД ни при чём. +5. После устранения: ошибки на входе падают, alert переходит в resolved за 1–2 минуты (окно 2 минуты). + +## QueueLagHigh + +**Условие.** Самое старое задание, готовое к обработке, ждёт worker дольше 60 с, 1 минуту подряд +(`max(messenger_queue_oldest_age_seconds) > 60`). Это отставание очереди, а не длительность обработки. + +**Шаги.** +1. Панель «Задания по исходу»: 0 доставок в секунду → worker не забирает задания. + «Насыщение worker»: если серия пропала — процесс worker не отправляет метрики (остановлен, упал). + Логи: `{service_name="messenger-worker"} | event=~"worker.stopped|worker.started|worker.broker_unavailable"`. + `make ps`: состояние контейнера worker. +2. Если worker работает, а насыщение 100% — не хватает мощности: `WORKER_REPLICAS=2 docker compose up -d worker`. +3. Если растёт «строка outbox ждёт брокер» — недоступен RabbitMQ (relay в API не может отправить): + логи `event="relay.unavailable"`. +4. Трасса загрузки, сделанной во время отказа (Tempo: `{ span.messenger.attachment.id = "" }`): + промежуток между `send attachments` и `process attachments.process` — время ожидания в очереди. +5. После запуска worker backlog уходит за секунды, alert — resolved на следующей проверке (15–30 с). + +## TelemetryExportFailing + +**Условие.** Collector не может отправить данные в Tempo, Loki или Prometheus (`otelcol_exporter_send_failed_*` +растёт или в очереди exporter больше 20 пачек) 1 минуту. + +**Шаги.** +1. Панель «Очереди exporter»: у какого exporter растёт очередь (`otlphttp/tempo`, `otlphttp/loki`, + `otlphttp/prometheus`) — то хранилище и недоступно. `make ps`, `docker compose logs <хранилище>`. +2. Бизнес-функции не затронуты: API и worker не ждут Collector. Проверка: `make test`. +3. Очередь ограничена (200 пачек), повторы — до 5 минут. Пока хранилище вернулось за это время, + данные доезжают из очереди; иначе отбрасываются и считаются в «не отправлено». +4. После запуска хранилища очередь разгружается, alert — resolved. diff --git a/infra/rabbitmq/20-messenger.conf b/infra/rabbitmq/20-messenger.conf new file mode 100644 index 0000000..8e759ec --- /dev/null +++ b/infra/rabbitmq/20-messenger.conf @@ -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 diff --git a/infra/sql/explain_history.sql b/infra/sql/explain_history.sql new file mode 100644 index 0000000..c2150d3 --- /dev/null +++ b/infra/sql/explain_history.sql @@ -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: синтетические данные удалены, индекс на месте' diff --git a/infra/tempo/tempo.yaml b/infra/tempo/tempo.yaml new file mode 100644 index 0000000..bc91842 --- /dev/null +++ b/infra/tempo/tempo.yaml @@ -0,0 +1,34 @@ +# Tempo 2.9.0 стенда lab6 — хранилище ТРАСС (один процесс, данные на диске в volume tempodata). +# +# Трассы приходят от Collector по OTLP/HTTP (:4318, только внутренняя сеть telemetry). +# Grafana ищет трассы по trace_id и по атрибутам (TraceQL), API запросов — :3200. +stream_over_http_enabled: true + +server: + http_listen_port: 3200 + log_level: warn + +distributor: + receivers: + otlp: + protocols: + http: + endpoint: 0.0.0.0:4318 + +ingester: + max_block_duration: 5m # блок трасс сбрасывается на диск не реже раза в 5 минут + +compactor: + compaction: + block_retention: 168h # 7 дней + +storage: + trace: + backend: local + wal: + path: /var/tempo/wal + local: + path: /var/tempo/blocks + +usage_report: + reporting_enabled: false diff --git a/infra/valkey/valkey.conf b/infra/valkey/valkey.conf new file mode 100644 index 0000000..21ae5b5 --- /dev/null +++ b/infra/valkey/valkey.conf @@ -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 diff --git a/migrations/001_core.sql b/migrations/001_core.sql new file mode 100644 index 0000000..712d969 --- /dev/null +++ b/migrations/001_core.sql @@ -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); diff --git a/migrations/002_sessions.sql b/migrations/002_sessions.sql new file mode 100644 index 0000000..e750c60 --- /dev/null +++ b/migrations/002_sessions.sql @@ -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); diff --git a/migrations/003_text_as_bytes.sql b/migrations/003_text_as_bytes.sql new file mode 100644 index 0000000..bae7417 --- /dev/null +++ b/migrations/003_text_as_bytes.sql @@ -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); diff --git a/migrations/004_message_idempotency.sql b/migrations/004_message_idempotency.sql new file mode 100644 index 0000000..94eb8fc --- /dev/null +++ b/migrations/004_message_idempotency.sql @@ -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); diff --git a/migrations/005_attachments.sql b/migrations/005_attachments.sql new file mode 100644 index 0000000..fce2698 --- /dev/null +++ b/migrations/005_attachments.sql @@ -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); diff --git a/migrations/006_jobs.sql b/migrations/006_jobs.sql new file mode 100644 index 0000000..a3ec3c7 --- /dev/null +++ b/migrations/006_jobs.sql @@ -0,0 +1,111 @@ +-- 006 (lab5): асинхронная обработка вложений — задания, transactional outbox, варианты, журнал. +-- +-- Что меняется по сравнению с lab4: +-- * загрузка больше не делает вложение готовым сразу. API кладёт оригинал в staging S3 +-- (staging/) и в ОДНОЙ транзакции пишет: строку вложения (queued), задание и строку outbox. +-- Только после COMMIT отвечает 202. Сообщение в брокер отправляет отдельный цикл (relay): +-- так «намерение обработать» не теряется, даже если брокер недоступен или API упал сразу +-- после COMMIT (transactional outbox); +-- * worker переводит задание queued -> processing -> ready/failed и пишет варианты. +-- +-- Состояния вложения (attachments.status, наружу отдаются как есть): +-- queued — оригинал в staging, задание сохранено, ждёт worker (или повтора после паузы); +-- processing — worker взял задание под lease (аренду) с крайним сроком; +-- ready — оригинал опубликован в originals/, все варианты записаны и закоммичены; +-- 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/: где лежит принятый оригинал до обработки. 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); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..357ceca --- /dev/null +++ b/requirements.txt @@ -0,0 +1,61 @@ +# Все зависимости закреплены точными версиями (включая транзитивные), +# чтобы сборка образа через месяц дала то же самое, что сегодня. +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 (кэш сессий) +# --- с lab6: наблюдаемость (OpenTelemetry SDK, автоинструментация) и их зависимости --- +asgiref==3.13.0 +certifi==2026.10.23 +charset-normalizer==3.5.2 +googleapis-common-protos==1.76.0 +opentelemetry-api==1.45.2 # API OpenTelemetry (трассы, метрики) — с lab6 +opentelemetry-exporter-http-transport==0.66b2 +opentelemetry-exporter-otlp-common==0.66b2 +opentelemetry-exporter-otlp-proto-common==1.45.2 +opentelemetry-exporter-otlp-proto-http==1.45.2 # отправка OTLP/HTTP в otel-collector — с lab6 +opentelemetry-instrumentation==0.66b2 +opentelemetry-instrumentation-asgi==0.66b2 +opentelemetry-instrumentation-botocore==0.66b2 # спаны запросов к S3 — с lab6 +opentelemetry-instrumentation-dbapi==0.66b2 +opentelemetry-instrumentation-fastapi==0.66b2 # server span и HTTP-метрики на каждый запрос — с lab6 +opentelemetry-instrumentation-logging==0.66b2 # LoggingHandler: логи -> OTLP с trace_id/span_id — с lab6 +opentelemetry-instrumentation-psycopg==0.66b2 # SQL-спаны (без параметров) — с lab6 +opentelemetry-instrumentation-system-metrics==0.66b2 # CPU и память процесса — с lab6 +opentelemetry-propagator-aws-xray==1.0.2 +opentelemetry-proto==1.45.2 +opentelemetry-sdk==1.45.2 # SDK: провайдеры, BatchProcessor, выборка трасс — с lab6 +opentelemetry-semantic-conventions==0.66b2 +opentelemetry-util-http==0.66b2 +packaging==26.3 +protobuf==7.36.2 +psutil==7.2.2 +requests==2.34.2 +wrapt==2.5.2 diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100755 index 0000000..21a1065 --- /dev/null +++ b/scripts/init-secrets.sh @@ -0,0 +1,75 @@ +#!/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 + +# С lab6: пароль администратора Grafana (http://127.0.0.1:3000, пользователь admin). +# Grafana читает его из файла (GF_SECURITY_ADMIN_PASSWORD__FILE), в переменных окружения его нет. +make_secret grafana_admin_password "" 24 + +# Файлы читают процессы в контейнерах под своими пользователями (postgres, valkey, app, seaweedfs, rabbitmq), +# поэтому сами файлы доступны на чтение; посторонних на хосте не пускает каталог (700). +chmod 644 secrets/* +echo "Готово: secrets/ (PostgreSQL, Valkey, S3 root и S3 для API, RabbitMQ, Grafana; значения не выводятся)." diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 0000000..8b996e8 --- /dev/null +++ b/scripts/restart.cmd @@ -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 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 0000000..6ec2519 --- /dev/null +++ b/scripts/restart.sh @@ -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 diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 0000000..5cef055 --- /dev/null +++ b/scripts/stop-one.cmd @@ -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% diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 0000000..e2bf8ad --- /dev/null +++ b/scripts/stop-one.sh @@ -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" diff --git a/scripts/stop_one.py b/scripts/stop_one.py new file mode 100644 index 0000000..bb484ea --- /dev/null +++ b/scripts/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 `. + +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()) diff --git a/src/messenger/__init__.py b/src/messenger/__init__.py new file mode 100644 index 0000000..470fbae --- /dev/null +++ b/src/messenger/__init__.py @@ -0,0 +1 @@ +"""Учебный мессенджер МТУСИ: REST API по contracts/openapi.json, данные в PostgreSQL.""" diff --git a/src/messenger/__main__.py b/src/messenger/__main__.py new file mode 100644 index 0000000..9c4230f --- /dev/null +++ b/src/messenger/__main__.py @@ -0,0 +1,58 @@ +"""Точка входа: `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. +Повторный сигнал останавливает процесс сразу, без ожидания. + +С lab6 до запуска сервера включается телеметрия (telemetry.py): трассы, метрики и логи по OTLP +в Collector, а приложение FastAPI инструментируется (server span и HTTP-метрики на каждый запрос). +После остановки сервера накопленная телеметрия отправляется (не дольше нескольких секунд). +""" +import logging +import threading + +import uvicorn + +from . import config, telemetry +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, extra={"event": "api.draining"}) + # Таймер в отдельном потоке: обработчик сигнала должен вернуться сразу. + threading.Timer(config.SHUTDOWN_DRAIN_SECONDS, super().handle_exit, (sig, frame)).start() + + +def main(): + telemetry.setup("messenger-api") + telemetry.instrument_fastapi(app) + 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, + log_config=None, # логи uvicorn идут через наш JSON-формат (telemetry.setup_logging) + )).run() + telemetry.shutdown() + + +if __name__ == "__main__": + main() diff --git a/src/messenger/api.py b/src/messenger/api.py new file mode 100644 index 0000000..41c4de8 --- /dev/null +++ b/src/messenger/api.py @@ -0,0 +1,427 @@ +"""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. +Что добавилось в lab6 (наблюдаемость, telemetry.py): +- каждый HTTP-запрос — server span (инструментация FastAPI, __main__.py) и точка в гистограмме + http.server.request.duration (метод, маршрут-шаблон, код ответа); /health/* не учитывается; +- строка лога на запрос — структурная (JSON в stdout и OTLP-лог): event=http.request, маршрут-шаблон, + код, длительность, request_id, а trace_id/span_id добавляются автоматически. X-Request-Id ответа + записан и в span (messenger.request_id), и в лог — по нему HTTP-ошибка находится в логах и трассах; +- у загрузки в span записан attachment_id, а в строку outbox — traceparent этого span (jobs.enqueue): + по нему relay и worker продолжают ту же трассу (upload -> publish -> consume -> S3/DB); +- метрики очереди и outbox (queuestats.py) и пула соединений с БД. +""" +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 opentelemetry import trace + +from . import attachments, config, db, faults, images, objects, security, telemetry +from .queuestats import QueueStats +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) +queue_stats = QueueStats() # метрики очереди заданий и outbox (с lab6) + +# Выставляется по 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) + telemetry.observe_pool(pool, "messenger-api") # метрики пула соединений (с lab6) + queue_stats.start() # метрики очереди и outbox (с lab6) + 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 "выключен", extra={"event": "api.started"}) + yield + queue_stats.stop() + relay.stop() # строки, которые не успели отправить, остаются в outbox + monitors_stop.set() + pool.close() # аккуратно закрываем соединения с БД при остановке + log.info("Реплика %s остановлена: соединения с PostgreSQL закрыты, данные остаются в базе", + config.INSTANCE_ID, extra={"event": "api.stopped"}) + + +app = FastAPI(title="MTUSI Messenger, lab6", 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() + # Server span создан инструментацией FastAPI снаружи этого middleware (для /health/* его нет). + span = trace.get_current_span() + span.set_attribute("messenger.request_id", request.state.request_id) + 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, + extra={"event": "http.unhandled_error", "request_id": 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-параметры, заголовки и даже сам путь (в нём ID чатов): + # только маршрут-шаблон. Успешные проверки /health/* балансировщика (2 в секунду) не пишем. + route = getattr(request.scope.get("route"), "path", None) or "unmatched" + if not (route.startswith("/health/") and response.status_code == 200): + duration_ms = round((time.perf_counter() - started) * 1000, 1) + log.log(logging.WARNING if response.status_code >= 500 else logging.INFO, + "%s %s -> %d (%.1f ms) request_id=%s", request.method, route, response.status_code, + duration_ms, request.state.request_id, + extra={"event": "http.request", "http.request.method": request.method, "http.route": route, + "http.response.status_code": response.status_code, "duration_ms": duration_ms, + "request_id": 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): + # Учебная точка отказа (lab6, инцидент 2): медленный обработчик при здоровой БД. + # Отдельного span нет намеренно: в трассе это «пустое» время server span без дочерних SQL-спанов. + time.sleep(faults.number("api_slow_handler")) + # Область ключа из контракта: пользователь + метод + путь чата + ключ. + # Метод и путь у этого обработчика всегда одни, поэтому в БД ключ уникален в паре (чат, отправитель). + 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, + extra={"event": "message.idempotent_replay"}) + 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) + # По attachment_id трасса загрузки находится в Tempo (технический ID синтетических данных, не label метрик). + trace.get_current_span().set_attribute("messenger.attachment.id", attachment.id) + # Разбудить 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, + extra={"event": "attachment.object_missing"}) + 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", + }) diff --git a/src/messenger/attachments.py b/src/messenger/attachments.py new file mode 100644 index 0000000..bb3f9d8 --- /dev/null +++ b/src/messenger/attachments.py @@ -0,0 +1,121 @@ +"""Приём вложения (с lab5 — асинхронный): POST /chats/{id}/attachments -> 202 queued. + +Что именно сохранено в момент 202 (contracts/attachment-states.md, переход «нет -> queued»): +1. полный проверенный оригинал — в staging S3 (staging/): 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/ (ключ назначает сервер); +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, + extra={"event": "attachment.upload_aborted"}) + 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, + extra={"event": "attachment.accepted", "attachment_id": attachment_id}) + 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 diff --git a/src/messenger/broker.py b/src/messenger/broker.py new file mode 100644 index 0000000..b2a23a0 --- /dev/null +++ b/src/messenger/broker.py @@ -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 diff --git a/src/messenger/cleanup.py b/src/messenger/cleanup.py new file mode 100644 index 0000000..a5a63e7 --- /dev/null +++ b/src/messenger/cleanup.py @@ -0,0 +1,136 @@ +"""Уборка объектов S3 (с lab4; с lab5 — staging и варианты): фоновый поток worker и команда. + +Зачем. Между записью байтов в S3 и COMMIT в PostgreSQL может случиться сбой, а staging после +обработки больше не нужен. Уборщик сверяет содержимое bucket с базой и удаляет то, на что +база не ссылается. + +Что нужно и не удаляется: +- оригинал ready-вложения (originals/) и все его варианты (variants//...); +- ВСЕ объекты вложения в работе (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 # только объекты одного вложения +Вывод — одна строка 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()) diff --git a/src/messenger/config.py b/src/messenger/config.py new file mode 100644 index 0000000..6519a59 --- /dev/null +++ b/src/messenger/config.py @@ -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") diff --git a/src/messenger/cursor.py b/src/messenger/cursor.py new file mode 100644 index 0000000..b183fab --- /dev/null +++ b/src/messenger/cursor.py @@ -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 diff --git a/src/messenger/db.py b/src/messenger/db.py new file mode 100644 index 0000000..d9ece0c --- /dev/null +++ b/src/messenger/db.py @@ -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) diff --git a/src/messenger/errors.py b/src/messenger/errors.py new file mode 100644 index 0000000..6bdda21 --- /dev/null +++ b/src/messenger/errors.py @@ -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" diff --git a/src/messenger/faults.py b/src/messenger/faults.py new file mode 100644 index 0000000..e5d5c18 --- /dev/null +++ b/src/messenger/faults.py @@ -0,0 +1,96 @@ +"""Внедрение отказов для проверок 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); +- api_slow_handler (с lab6) обработчик POST сообщения «думает» N секунд до обращения к БД: + медленный HTTP handler при здоровой БД (сравнение с медленной БД в инциденте 2). +Точки-паузы (замечание к 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 diff --git a/src/messenger/images.py b/src/messenger/images.py new file mode 100644 index 0000000..dccdf4e --- /dev/null +++ b/src/messenger/images.py @@ -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"} +# Символы управления направлением текста: позволяют показать «photo‮gnp.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() diff --git a/src/messenger/imaging.py b/src/messenger/imaging.py new file mode 100644 index 0000000..98beaa9 --- /dev/null +++ b/src/messenger/imaging.py @@ -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)) diff --git a/src/messenger/jobs.py b/src/messenger/jobs.py new file mode 100644 index 0000000..70f4f9a --- /dev/null +++ b/src/messenger/jobs.py @@ -0,0 +1,484 @@ +"""Задания обработки вложений в 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 и журнал +меняются вместе или не меняются вовсе. + +С lab6 в каждой строке outbox есть W3C traceparent (contracts/jobs.schema.json, необязательное поле): +- при загрузке — span HTTP-запроса upload; +- при повторе из worker — span обработки задания (consumer), поэтому повтор — продолжение той же трассы; +- без активного span (истёкший lease в фоновом потоке, страховочная переотправка, replay оператора) — + traceparent прошлой строки этого задания: цепочка не рвётся. +complete() возвращает время от durable acceptance (attachments.created_at, транзакция загрузки) +до COMMIT ready — для гистограммы messenger.attachment.time_to_ready. +""" +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, telemetry +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) + telemetry.inject(payload) + if "traceparent" not in payload: + row = conn.execute("""SELECT payload->>'traceparent', payload->>'tracestate' FROM outbox + WHERE job_id = %s AND payload ? 'traceparent' ORDER BY id DESC LIMIT 1""", + (job_id,)).fetchone() + if row is not None: + payload["traceparent"] = row[0] + if row[1]: + payload["tracestate"] = row[1] + 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- или 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]) -> float | None: + """processing -> ready: варианты, статус вложения и задания — одной транзакцией. + + Возвращает секунды от принятия загрузки до ready или None, если lease уже не наш. + """ + with self._tx() as conn: + if self._fenced(conn, lease) is None: + return None + 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)) + row = conn.execute("""UPDATE attachments SET status = 'ready', error_code = NULL, updated_at = now() + WHERE id = %s AND status IN ('queued', 'processing') + RETURNING EXTRACT(EPOCH FROM clock_timestamp() - created_at)""", + (attachment_id,)).fetchone() + 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 float(row[0]) if row is not None else 0.0 + + 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 состояние, журнал, outbox, варианты + python -m messenger.jobs replay [--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()) diff --git a/src/messenger/migrate.py b/src/messenger/migrate.py new file mode 100644 index 0000000..68a57a4 --- /dev/null +++ b/src/messenger/migrate.py @@ -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()) diff --git a/src/messenger/objects.py b/src/messenger/objects.py new file mode 100644 index 0000000..0b4cfd5 --- /dev/null +++ b/src/messenger/objects.py @@ -0,0 +1,300 @@ +"""Объектное хранилище S3 (SeaweedFS): байты вложений (с lab4). + +Источник истины для СОДЕРЖИМОГО файла — приватный bucket, для МЕТАДАННЫХ — PostgreSQL. +Ни одна реплика API не хранит оригинал у себя: любая реплика скачивает его из общего S3, +поэтому файл доступен и после остановки реплики, которая его приняла. + +Ключи объектов (с lab5) назначает сервер, имя файла от клиента в них не попадает: +- staging/ — принятый оригинал до обработки (его пишет API перед ответом 202); +- originals/ — опубликованный оригинал (его пишет worker перед статусом ready); +- variants//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 contextvars +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): + # copy_context (с lab6): контекст трассы вызывающего потока переходит в поток S3, поэтому запрос + # к S3 (span botocore) становится дочерним span HTTP-запроса или обработки задания. + future = _pool.submit(contextvars.copy_context().run, 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/, originals/, variants//... + Для ключа другого вида — 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// + 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 diff --git a/src/messenger/queuestats.py b/src/messenger/queuestats.py new file mode 100644 index 0000000..6de4d8c --- /dev/null +++ b/src/messenger/queuestats.py @@ -0,0 +1,101 @@ +"""Метрики очереди заданий (с lab6): глубина и возраст старейшего задания, outbox. + +Считаются в каждой реплике API (а не в worker): во время инцидента «worker остановлен» именно +эти графики должны расти, а остановленный worker ничего бы не отправил. Обе реплики отдают одно и +то же значение, в запросах dashboard берётся max по репликам. + +Источник — PostgreSQL (источник истины о заданиях), а не счётчик брокера: брокер хранит только +«напоминания», а задание может ждать и в outbox (брокер недоступен), и в паузе backoff. + + messenger.queue.depth{queue, state} state = ready (ждёт worker), delayed (пауза перед повтором), + processing (под lease) [{job}] + messenger.queue.oldest_age{queue} сколько ждёт самое старое задание в состоянии ready, с момента, + когда его можно брать (next_attempt_at) [s] + messenger.outbox.pending строки outbox, которые пора отправить, но брокер их ещё + не подтвердил [{message}] + messenger.outbox.oldest_age возраст самой старой такой строки [s] + +Backlog (depth) и lag (oldest_age) — не то же самое, что время обработки задания: это время +ожидания до начала обработки. Время обработки — гистограмма messenger.job.duration (worker), +полный путь до ready — messenger.attachment.time_to_ready. +""" +import logging +import threading + +import psycopg +from opentelemetry import metrics + +from . import config, db, telemetry + +log = logging.getLogger("messenger.queuestats") + +INTERVAL_SECONDS = 5.0 + +_SQL_JOBS = """ +SELECT count(*) FILTER (WHERE status = 'queued' AND next_attempt_at <= now()), + count(*) FILTER (WHERE status = 'queued' AND next_attempt_at > now()), + count(*) FILTER (WHERE status = 'processing'), + COALESCE(EXTRACT(EPOCH FROM now() - min(next_attempt_at) + FILTER (WHERE status = 'queued' AND next_attempt_at <= now())), 0) +FROM attachment_jobs WHERE status IN ('queued', 'processing')""" + +_SQL_OUTBOX = """ +SELECT count(*), COALESCE(EXTRACT(EPOCH FROM now() - min(available_at)), 0) +FROM outbox WHERE published_at IS NULL AND available_at <= now()""" + + +class QueueStats: + def __init__(self): + self._values = telemetry.Sampled(max_age=3 * INTERVAL_SECONDS) + self._stop = threading.Event() + self._conn = None + + def start(self) -> None: + if not telemetry.enabled(): + return + m = metrics.get_meter("messenger") + q = {"queue": telemetry.QUEUE_NAME} + m.create_observable_gauge("messenger.queue.depth", [self._depth], unit="{job}", + description="Задания в очереди по состоянию") + m.create_observable_gauge("messenger.queue.oldest_age", [self._field(3, q)], unit="s", + description="Ожидание самого старого задания, готового к обработке") + m.create_observable_gauge("messenger.outbox.pending", [self._field(4, q)], unit="{message}", + description="Неотправленные строки outbox, которые пора отправить") + m.create_observable_gauge("messenger.outbox.oldest_age", [self._field(5, q)], unit="s", + description="Возраст самой старой неотправленной строки outbox") + threading.Thread(target=self._loop, name="queue-stats", daemon=True).start() + + def stop(self) -> None: + self._stop.set() + + def _depth(self, _options): + values = self._values.get() + if values is None: + return [] + return [metrics.Observation(values[i], {"queue": telemetry.QUEUE_NAME, "state": state}) + for i, state in enumerate(("ready", "delayed", "processing"))] + + def _field(self, index: int, attrs: dict): + def callback(_options): + values = self._values.get() + return [] if values is None else [metrics.Observation(values[index], attrs)] + return callback + + def _loop(self) -> None: + while not self._stop.wait(INTERVAL_SECONDS): + try: + if self._conn is None or self._conn.closed: + kwargs = db.connection_kwargs("messenger-queue-stats") + self._conn = psycopg.connect(config.DATABASE_URL, autocommit=True, **kwargs) + jobs = self._conn.execute(_SQL_JOBS).fetchone() + outbox = self._conn.execute(_SQL_OUTBOX).fetchone() + self._values.put((int(jobs[0]), int(jobs[1]), int(jobs[2]), float(jobs[3]), + int(outbox[0]), float(outbox[1]))) + except psycopg.Error: + # БД недоступна: значения устареют и перестанут отдаваться (пропуск на графике). + try: + if self._conn is not None: + self._conn.close() + except psycopg.Error: + pass + self._conn = None diff --git a/src/messenger/relay.py b/src/messenger/relay.py new file mode 100644 index 0000000..8444a0e --- /dev/null +++ b/src/messenger/relay.py @@ -0,0 +1,169 @@ +"""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. + +С lab6 каждая отправка — PRODUCER span «send attachments» (semconv messaging). Его родитель — +traceparent из строки outbox (span загрузки или обработки, создавшей задание), а в сообщение +брокера уходит traceparent уже этого span: consumer span worker станет его дочерним. +Так одна трасса показывает upload -> publish -> consume, даже если relay отправил строку позже +или другой репликой. Опрос outbox (SQL раз в секунду) трасс не создаёт: CLIENT-спаны без родителя +отбрасываются выборкой (telemetry._sampler). +""" +import logging +import threading + +import psycopg + +from opentelemetry.trace import SpanKind + +from . import broker, config, db, faults, telemetry + +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 отправляется", + extra={"event": "relay.healthy"}) + else: + log.warning("relay: не могу отправить outbox (%s), строки ждут в PostgreSQL", reason, + extra={"event": "relay.unavailable"}) + 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: неожиданная ошибка", extra={"event": "relay.error"}) + 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._send(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) + telemetry.instruments.create().outbox_published.add(len(sent)) + log.info("relay: отправлено в брокер %d (подтверждено), всего %d", len(sent), self.published_total, + extra={"event": "relay.published", "count": len(sent)}) + if error is not None: + raise error + return len(rows) + + def _send(self, payload: dict) -> None: + """Одна публикация с publisher confirm внутри PRODUCER span (родитель — traceparent строки).""" + message = {k: v for k, v in payload.items() if k not in ("traceparent", "tracestate")} + attributes = {"messaging.system": "rabbitmq", "messaging.operation.type": "send", + "messaging.operation.name": "publish", "messaging.destination.name": broker.EXCHANGE, + "messaging.rabbitmq.destination.routing_key": broker.ROUTING_KEY, + "messaging.message.id": f"{payload['job_id']}:{payload['attempt']}", + "messenger.job.type": telemetry.JOB_TYPE, "messenger.job.id": payload["job_id"], + "messenger.job.attempt": payload["attempt"], + "messenger.attachment.id": payload["attachment_id"]} + with telemetry.span(f"send {broker.EXCHANGE}", SpanKind.PRODUCER, telemetry.extract(payload), attributes): + telemetry.inject(message) # traceparent этого span -> consumer span worker + if "traceparent" not in message and "traceparent" in payload: + message["traceparent"] = payload["traceparent"] # телеметрия выключена: передаём как было + self._publisher.publish(message) + diff --git a/src/messenger/s3bootstrap.py b/src/messenger/s3bootstrap.py new file mode 100644 index 0000000..e5cd0b7 --- /dev/null +++ b/src/messenger/s3bootstrap.py @@ -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()) diff --git a/src/messenger/sandbox.py b/src/messenger/sandbox.py new file mode 100644 index 0000000..6c4079a --- /dev/null +++ b/src/messenger/sandbox.py @@ -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) diff --git a/src/messenger/security.py b/src/messenger/security.py new file mode 100644 index 0000000..41f8599 --- /dev/null +++ b/src/messenger/security.py @@ -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$<соль>$ + + +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 diff --git a/src/messenger/sessions.py b/src/messenger/sessions.py new file mode 100644 index 0000000..8ea3e43 --- /dev/null +++ b/src/messenger/sessions.py @@ -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)) diff --git a/src/messenger/store.py b/src/messenger/store.py new file mode 100644 index 0000000..ce2e81f --- /dev/null +++ b/src/messenger/store.py @@ -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 diff --git a/src/messenger/telemetry.py b/src/messenger/telemetry.py new file mode 100644 index 0000000..6b00995 --- /dev/null +++ b/src/messenger/telemetry.py @@ -0,0 +1,383 @@ +"""Телеметрия (с lab6): трассы, метрики и логи через OpenTelemetry SDK -> OTLP -> OTel Collector. + +Процессы приложения ничего не хранят и не знают о Prometheus/Loki/Tempo: они отправляют три сигнала +по OTLP/HTTP в Collector (OTEL_EXPORTER_OTLP_ENDPOINT), а он раскладывает их по хранилищам. +Вызывается один раз при старте процесса: API (`python -m messenger`) и worker. Одноразовые +процессы (migrate, s3-init, CLI оператора) телеметрию не включают. + +Ресурс (атрибуты, общие для всех сигналов процесса), contracts/observability.md: + service.name messenger-api | messenger-worker (OTEL_SERVICE_NAME) + service.version APP_VERSION (build arg) + service.instance.id INSTANCE_ID = hostname контейнера (как X-Instance-Id) + deployment.environment.name = lab (OTEL_RESOURCE_ATTRIBUTES) + +Что НЕ попадает в телеметрию: тела запросов и сообщений, картинки, пароли, Authorization, +токены сессий, query-строки (filename, cursor). В логах и трассах — только ограниченные технические +ID (request_id, attachment_id, job_id) синтетических учебных данных: по ним upload связывается с +обработкой. В labels метрик ID нет вовсе: только маршрут-шаблон, метод, код, тип задания, исход. + +Ограниченное поведение при недоступном Collector (третий сценарий контракта): +- трассы и логи копятся в очереди процесса (BatchProcessor) не больше чем MAX_QUEUE записей; + что не влезло — отбрасывается, а не копится в памяти; +- каждая отправка ограничена OTEL_EXPORTER_OTLP_TIMEOUT (5 с в .env; Python SDK читает его в секундах); +- метрики — накопительные (cumulative): пропущенная отправка не теряет счётчики, следующая + отправка несёт полные значения. +Отправка идёт в фоновых потоках SDK, поэтому обработка запросов не ждёт Collector. +""" +import json +import logging +import os +import sys +import threading +import time +from contextlib import contextmanager +from datetime import datetime, timezone + +from opentelemetry import metrics, trace +from opentelemetry.trace import SpanKind, Status, StatusCode +from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator + +from . import config + +log = logging.getLogger("messenger.telemetry") + +# Только W3C Trace Context (traceparent/tracestate): поле baggage в сообщении брокера запрещено +# contracts/jobs.schema.json (additionalProperties: false), поэтому глобальный пропагатор не используем. +_PROPAGATOR = TraceContextTextMapPropagator() + +MAX_QUEUE = 2048 # записей в очереди процесса на сигнал (трассы, логи) +EXPORT_BATCH = 512 +METRIC_INTERVAL_MS = int(os.environ.get("OTEL_METRIC_EXPORT_INTERVAL", "10000")) + +# Границы buckets гистограмм (секунды) — под ожидаемые задержки, а не значения по умолчанию. +# HTTP: границы задаёт сама инструментация FastAPI (semconv: 5 мс … 10 с). +JOB_DURATION_BUCKETS = (0.1, 0.25, 0.5, 1, 2, 3, 5, 10, 20, 30, 60, 120) +TIME_TO_READY_BUCKETS = (0.5, 1, 2, 3, 5, 10, 20, 30, 60, 120, 300, 600, 1800) + +QUEUE_NAME = "attachments.process" +JOB_TYPE = "attachment.process" + +_enabled = False +_providers = [] +tracer = trace.get_tracer("messenger") +meter = metrics.get_meter("messenger") + + +def enabled() -> bool: + return _enabled + + +# ---------- выборка трасс ---------- + +def _sampler(): + """ParentBased(корень = всё, КРОМЕ «сиротских» CLIENT-спанов). + + Фоновые циклы (relay опрашивает outbox раз в секунду, продление lease, проверка S3 для + readiness, сбор метрик очереди) делают SQL и S3-запросы без входящего запроса. Без фильтра + каждый такой запрос стал бы отдельной трассой из одного спана и забил бы Tempo шумом. + Запросы к БД и S3 внутри HTTP-запроса или обработки задания имеют родителя и сохраняются все. + """ + from opentelemetry.sdk.trace.sampling import ALWAYS_ON, Decision, ParentBased, Sampler, SamplingResult + + class DropOrphanClientSpans(Sampler): + def should_sample(self, parent_context, trace_id, name, kind=None, attributes=None, links=None, + trace_state=None): + if kind == SpanKind.CLIENT: + return SamplingResult(Decision.DROP) + return ALWAYS_ON.should_sample(parent_context, trace_id, name, kind, attributes, links, trace_state) + + def get_description(self): + return "DropOrphanClientSpans" + + return ParentBased(root=DropOrphanClientSpans()) + + +# ---------- логи ---------- + +class _EventFilter(logging.Filter): + """У каждой записи есть поле event (имя события): задаётся через extra={"event": ...}. + + Записи без явного события получают имя логгера (messenger.worker и т.п.). + """ + + def filter(self, record): + if not getattr(record, "event", None): + record.event = record.name + return True + + +class _NotTelemetryItself(logging.Filter): + """Логи самого SDK и HTTP-клиента экспортёра не отправляются по OTLP: иначе при недоступном + Collector каждая ошибка отправки порождала бы новую запись для отправки.""" + + def filter(self, record): + return not record.name.startswith(("opentelemetry", "urllib3", "requests")) + + +_STD = set(vars(logging.LogRecord("", 0, "", 0, "", None, None))) | {"message", "asctime", "taskName"} + + +class JsonFormatter(logging.Formatter): + """Структурный лог в stdout (docker compose logs): одна строка JSON на запись. + + Поля: timestamp, severity, service.name, event, logger, message, trace_id/span_id (если есть + активный span) и дополнительные поля из extra (request_id, route, status…). + """ + + def __init__(self, service: str): + super().__init__() + self.service = service + + def format(self, record): + entry = { + "timestamp": datetime.fromtimestamp(record.created, timezone.utc).isoformat(timespec="milliseconds"), + "severity": record.levelname, + "service.name": self.service, + "event": getattr(record, "event", record.name), + "logger": record.name, + "message": record.getMessage(), + } + ctx = trace.get_current_span().get_span_context() + if ctx.is_valid: + entry["trace_id"] = format(ctx.trace_id, "032x") + entry["span_id"] = format(ctx.span_id, "016x") + for key, value in vars(record).items(): + if key not in _STD and key not in entry and key != "event": + entry[key] = value if isinstance(value, (str, int, float, bool)) or value is None else str(value) + if record.exc_info: + entry["exception"] = self.formatException(record.exc_info) + return json.dumps(entry, ensure_ascii=False) + + +def setup_logging(service: str) -> None: + root = logging.getLogger() + root.handlers.clear() + root.setLevel(logging.INFO) + stdout = logging.StreamHandler(sys.stdout) + stdout.addFilter(_EventFilter()) + stdout.setFormatter(JsonFormatter(service)) + root.addHandler(stdout) + for noisy in ("pika", "botocore", "boto3", "urllib3", "s3transfer"): + logging.getLogger(noisy).setLevel(logging.WARNING) + + +# ---------- инициализация ---------- + +def setup(service_name: str) -> None: + """Включить телеметрию процесса. Без OTEL_EXPORTER_OTLP_ENDPOINT (или OTEL_SDK_DISABLED=true) — + только структурные логи в stdout, SDK не создаётся (так работают тесты внутри образа).""" + global _enabled + os.environ.setdefault("OTEL_SERVICE_NAME", service_name) + service = os.environ["OTEL_SERVICE_NAME"] + setup_logging(service) + if os.environ.get("OTEL_SDK_DISABLED", "").lower() == "true" or not os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT"): + log.info("Телеметрия выключена: OTLP endpoint не задан", extra={"event": "telemetry.disabled"}) + return + + from opentelemetry._logs import set_logger_provider + from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter + from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter + from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter + from opentelemetry.instrumentation.logging.handler import LoggingHandler + from opentelemetry.sdk._logs import LoggerProvider + from opentelemetry.sdk._logs.export import BatchLogRecordProcessor + from opentelemetry.sdk.metrics import MeterProvider + from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader + from opentelemetry.sdk.metrics.view import ExplicitBucketHistogramAggregation, View + from opentelemetry.sdk.resources import Resource + from opentelemetry.sdk.trace import TracerProvider + from opentelemetry.sdk.trace.export import BatchSpanProcessor + + # Resource.create сам читает OTEL_SERVICE_NAME и OTEL_RESOURCE_ATTRIBUTES (deployment.environment.name). + resource = Resource.create({"service.version": config.APP_VERSION, + "service.instance.id": config.INSTANCE_ID}) + + tracer_provider = TracerProvider(resource=resource, sampler=_sampler()) + tracer_provider.add_span_processor(BatchSpanProcessor( + OTLPSpanExporter(), max_queue_size=MAX_QUEUE, max_export_batch_size=EXPORT_BATCH, schedule_delay_millis=2000)) + trace.set_tracer_provider(tracer_provider) + + views = [ + View(instrument_name="messenger.job.duration", + aggregation=ExplicitBucketHistogramAggregation(JOB_DURATION_BUCKETS)), + View(instrument_name="messenger.attachment.time_to_ready", + aggregation=ExplicitBucketHistogramAggregation(TIME_TO_READY_BUCKETS)), + ] + meter_provider = MeterProvider(resource=resource, views=views, metric_readers=[ + PeriodicExportingMetricReader(OTLPMetricExporter(), export_interval_millis=METRIC_INTERVAL_MS)]) + metrics.set_meter_provider(meter_provider) + + logger_provider = LoggerProvider(resource=resource) + logger_provider.add_log_record_processor(BatchLogRecordProcessor( + OTLPLogExporter(), max_queue_size=MAX_QUEUE, max_export_batch_size=EXPORT_BATCH, schedule_delay_millis=2000)) + set_logger_provider(logger_provider) + otlp_handler = LoggingHandler(level=logging.INFO, logger_provider=logger_provider) + otlp_handler.addFilter(_EventFilter()) + otlp_handler.addFilter(_NotTelemetryItself()) + logging.getLogger().addHandler(otlp_handler) + + _providers[:] = [tracer_provider, meter_provider, logger_provider] + + # Автоинструментация: SQL-запросы psycopg и запросы к S3 (botocore) как дочерние CLIENT-спаны. + # Параметры SQL не записываются (только текст запроса с плейсхолдерами %s). + from opentelemetry.instrumentation.botocore import BotocoreInstrumentor + from opentelemetry.instrumentation.psycopg import PsycopgInstrumentor + PsycopgInstrumentor().instrument(enable_commenter=False, skip_dep_check=True) + BotocoreInstrumentor().instrument() + # CPU и память процесса (process.cpu.time, process.memory.usage): нагрузка на контейнер. + from opentelemetry.instrumentation.system_metrics import SystemMetricsInstrumentor + SystemMetricsInstrumentor(config={ + "process.cpu.time": ["user", "system"], + "process.cpu.utilization": None, + "process.memory.usage": None, + "process.thread.count": None, + }).instrument() + + _enabled = True + log.info("Телеметрия включена: OTLP -> %s", os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"], + extra={"event": "telemetry.enabled"}) + + +def instrument_fastapi(app) -> None: + if not _enabled: + return + from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor + # /health/* не трассируется и не попадает в HTTP-метрики: это служебные запросы балансировщика, + # а не бизнес-запросы (знаменатель доли ошибок, см. REPORT.md). + # exclude_spans: без внутренних спанов «http receive/send» на каждый кусок тела. + FastAPIInstrumentor.instrument_app(app, excluded_urls="/health/", exclude_spans=["receive", "send"]) + + +def shutdown() -> None: + """Отправить накопленное при остановке (не дольше нескольких секунд на сигнал).""" + for provider in _providers: + try: + if hasattr(provider, "force_flush"): + provider.force_flush(3000) + provider.shutdown() + except Exception: # остановку процесса телеметрия не задерживает + pass + _providers.clear() + + +# ---------- контекст трассы через брокер ---------- + +def inject(message: dict) -> None: + """Записать traceparent/tracestate активного span в сообщение (если span есть).""" + _PROPAGATOR.inject(message) + + +def extract(message: dict): + """Контекст родителя из сообщения брокера (или пустой, если traceparent нет).""" + return _PROPAGATOR.extract({k: message[k] for k in ("traceparent", "tracestate") if k in message}) + + +def current_trace_id() -> str | None: + ctx = trace.get_current_span().get_span_context() + return format(ctx.trace_id, "032x") if ctx.is_valid else None + + +@contextmanager +def span(name: str, kind: SpanKind = SpanKind.INTERNAL, context=None, attributes: dict | None = None): + """Span с записью исключения и статусом ERROR при ошибке.""" + with tracer.start_as_current_span(name, context=context, kind=kind, attributes=attributes, + record_exception=True, set_status_on_exception=True) as current: + yield current + + +def set_error(current, description: str) -> None: + current.set_status(Status(StatusCode.ERROR, description)) + + +# ---------- метрики приложения ---------- +# Инструменты создаются один раз. Без setup() глобальный провайдер — no-op: вызовы ничего не делают. + +class _Instruments: + def __init__(self): + self.ready = False + + def create(self): + if self.ready: + return self + m = metrics.get_meter("messenger") + # Worker: задания. Labels только job type и outcome (не attachment_id!). + self.jobs_processed = m.create_counter( + "messenger.jobs.processed", unit="{job}", + description="Доставки заданий, обработанные worker, по исходу") + self.job_duration = m.create_histogram( + "messenger.job.duration", unit="s", + description="Длительность одной попытки обработки задания worker") + self.time_to_ready = m.create_histogram( + "messenger.attachment.time_to_ready", unit="s", + description="От durable acceptance (COMMIT загрузки) до COMMIT ready") + # Relay outbox (API). + self.outbox_published = m.create_counter( + "messenger.outbox.published", unit="{message}", + description="Сообщения outbox, подтверждённые брокером (publisher confirm)") + self.ready = True + return self + + +instruments = _Instruments() + + +class Sampled: + """Значения для observable-gauge, которые считает отдельный поток (например, SQL к БД). + + Callback сбора метрик только читает готовое значение: если БД зависла, зависнет фоновый поток + сбора, но не экспорт ВСЕХ метрик процесса. Значение старше max_age не отдаётся (пропуск в графике + честнее, чем застывшая цифра). + """ + + def __init__(self, max_age: float = 30.0): + self._values = None + self._at = 0.0 + self._max_age = max_age + self._lock = threading.Lock() + + def put(self, values) -> None: + with self._lock: + self._values, self._at = values, time.monotonic() + + def get(self): + with self._lock: + if self._values is None or time.monotonic() - self._at > self._max_age: + return None + return self._values + + +def observe_pool(pool, pool_name: str) -> None: + """DB pool: соединения used/idle, максимум и ожидающие запросы (semconv db.client.connection.*).""" + m = metrics.get_meter("messenger") + + def stats(): + try: + return pool.get_stats() + except Exception: + return None + + def count(_options): + s = stats() + if s is None: + return [] + size, available = s.get("pool_size", 0), s.get("pool_available", 0) + attrs = {"db.client.connection.pool.name": pool_name} + return [metrics.Observation(size - available, attrs | {"db.client.connection.state": "used"}), + metrics.Observation(available, attrs | {"db.client.connection.state": "idle"})] + + def maximum(_options): + s = stats() + return [] if s is None else [metrics.Observation(s.get("pool_max", 0), + {"db.client.connection.pool.name": pool_name})] + + def pending(_options): + s = stats() + return [] if s is None else [metrics.Observation(s.get("requests_waiting", 0), + {"db.client.connection.pool.name": pool_name})] + + m.create_observable_up_down_counter("db.client.connection.count", [count], unit="{connection}", + description="Соединения пула по состоянию") + m.create_observable_up_down_counter("db.client.connection.max", [maximum], unit="{connection}", + description="Максимальный размер пула") + m.create_observable_up_down_counter("db.client.connection.pending_requests", [pending], unit="{request}", + description="Запросы, ждущие свободное соединение пула") diff --git a/src/messenger/worker.py b/src/messenger/worker.py new file mode 100644 index 0000000..c241ccb --- /dev/null +++ b/src/messenger/worker.py @@ -0,0 +1,493 @@ +"""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/ и варианты в variants//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 упал или +завис), и возвращает их в очередь. + +Наблюдаемость (с lab6, telemetry.py): +- каждая доставка — CONSUMER span «process attachments.process», родитель — traceparent из сообщения + (PRODUCER span relay). Внутри — jobs.claim, скачивание из S3, image.process (дочерний процесс), + запись в S3, jobs.complete / jobs.retry / jobs.fail; SQL и S3 — автоматические дочерние спаны. + Повтор пишет в outbox traceparent этого span, поэтому следующая попытка — в той же трассе; +- метрики: messenger.jobs.processed{messenger.job.type, outcome} (каждая доставка), + messenger.job.duration{messenger.job.type, outcome} (попытки, взятые в работу), + messenger.attachment.time_to_ready, messenger.worker.busy / capacity, пул соединений с БД; +- структурные логи с event (job.ready, job.retry, job.failed…), trace_id и span_id. +""" +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 opentelemetry import metrics +from opentelemetry.trace import SpanKind + +from . import broker, cleanup, config, db, faults, imaging, jobs, objects, sandbox, telemetry +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() + self._observe() + 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, extra={"event": "worker.started"}) + 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, extra={"event": "worker.stopped"}) + + 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 _observe(self) -> None: + """Метрики насыщения worker: занято / всего слотов, и пул соединений с БД.""" + telemetry.observe_pool(self.pool, "messenger-worker") + m = metrics.get_meter("messenger") + m.create_observable_gauge("messenger.worker.busy", [lambda _o: [metrics.Observation(self._busy())]], + unit="{job}", description="Доставки в работе (ещё без ack/nack)") + m.create_observable_gauge("messenger.worker.capacity", + [lambda _o: [metrics.Observation(config.WORKER_CONCURRENCY)]], + unit="{job}", description="Сколько заданий worker обрабатывает одновременно") + + 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, + extra={"event": "worker.broker_unavailable"}) + 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("Неожиданная ошибка обработки сообщения: вернётся в очередь", + extra={"event": "job.unexpected_error"}) + 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 _count(self, outcome: str, started: float | None = None) -> None: + tools = telemetry.instruments.create() + attrs = {"messenger.job.type": telemetry.JOB_TYPE, "outcome": outcome} + tools.jobs_processed.add(1, attrs) + if started is not None: + tools.job_duration.record(time.monotonic() - started, attrs) + + def _process(self, body: bytes) -> str: + base = {"messaging.system": "rabbitmq", "messaging.operation.type": "process", + "messaging.destination.name": broker.QUEUE, "messenger.job.type": telemetry.JOB_TYPE} + try: + message = broker.parse(body) + except broker.InvalidMessage as exc: + with telemetry.span(f"process {broker.QUEUE}", SpanKind.CONSUMER, attributes=base) as span: + telemetry.set_error(span, "invalid_message") + span.set_attribute("messenger.job.outcome", "invalid") + log.error("Сообщение не по схеме jobs.schema.json (%s): reject -> DLQ", exc, + extra={"event": "job.invalid_message"}) + self._count("invalid") + return "reject" + attrs = base | {"messaging.message.id": f"{message['job_id']}:{message['attempt']}", + "messenger.job.id": message["job_id"], "messenger.job.attempt": message["attempt"], + "messenger.attachment.id": message["attachment_id"]} + with telemetry.span(f"process {broker.QUEUE}", SpanKind.CONSUMER, telemetry.extract(message), attrs) as span: + action, outcome, started = self._process_message(message) + span.set_attribute("messenger.job.outcome", outcome) + if outcome in ("failed", "retry", "db_unavailable"): + telemetry.set_error(span, outcome) + self._count(outcome, started) + return action + + def _process_message(self, message: dict) -> tuple[str, str, float | None]: + """Возвращает (действие с сообщением, исход для метрик, начало работы или None).""" + with telemetry.span("jobs.claim"): + decision = self._claim(message) + if decision is None: + log.warning("PostgreSQL недоступен: задание %s вернётся в очередь", message["job_id"], + extra={"event": "job.requeue", "job_id": message["job_id"]}) + return "requeue", "db_unavailable", None + if decision.kind != "claimed": + log.info("Задание %s попытка %d: %s %s — ack без обработки", message["job_id"], message["attempt"], + decision.kind, decision.detail, + extra={"event": "job.skipped", "job_id": message["job_id"], "decision": decision.kind}) + return "ack", "skipped", None + lease = decision.lease + item = InFlight(lease, threading.Event(), time.monotonic()) + with self.lock: + self.inflight[lease.token] = item + try: + action, outcome = self._run_job(item) + return action, outcome, item.started + finally: + with self.lock: + self.inflight.pop(lease.token, None) + + def _run_job(self, item: InFlight) -> tuple[str, str]: + lease = item.lease + ids = {"job_id": lease.job_id, "attachment_id": lease.attachment_id, "attempt": lease.attempt} + try: + try: + variants = self._produce(lease, item.abort) + faults.pause("worker_pause_after_objects") # проверка уборщика: объекты есть, COMMIT ещё нет + faults.hit("worker_after_objects") # объекты в S3 есть, COMMIT и ack — нет + with telemetry.span("jobs.complete"): + waited = self.jobs.complete(lease, variants) + if waited is None: + log.warning("Задание %s: lease потерян до COMMIT — результат не записан", lease.job_id, + extra={"event": "job.lease_lost"} | ids) + return "ack", "lost" + telemetry.instruments.create().time_to_ready.record(waited, {"messenger.job.type": telemetry.JOB_TYPE}) + faults.hit("worker_after_commit") # результат закоммичен, ack — нет + self._drop_staging(lease) + log.info("Вложение %s готово: попытка %d за %.2f с", lease.attachment_id, lease.attempt, + time.monotonic() - item.started, + extra={"event": "job.ready", "time_to_ready_s": round(waited, 3)} | ids) + return "ack", "ready" + except Permanent as exc: + log.warning("Вложение %s: постоянная ошибка %s (%s) -> failed", lease.attachment_id, exc.code, exc, + extra={"event": "job.failed", "error_code": exc.code} | ids) + with telemetry.span("jobs.fail", attributes={"messenger.job.error_code": exc.code}): + recorded = self.jobs.fail(lease, exc.code, str(exc)) + return ("reject", "failed") if recorded else ("ack", "lost") + except Transient as exc: + with telemetry.span("jobs.retry", attributes={"messenger.job.error_code": exc.code}): + 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, + extra={"event": "job.failed" if outcome == "failed" else "job.retry", + "error_code": exc.code} | ids) + if outcome == "failed": + return "reject", "failed" + return "ack", "retry" if outcome == "retry" else "lost" + except LeaseLost: + log.warning("Задание %s: lease забрал другой worker — работа брошена", lease.job_id, + extra={"event": "job.lease_lost"} | ids) + return "ack", "lost" + except Unavailable: + # PostgreSQL недоступен: исход не записан. Сообщение вернётся; lease истечёт сам. + log.warning("Задание %s: PostgreSQL недоступен, исход не записан — сообщение вернётся в очередь", + lease.job_id, extra={"event": "job.requeue"} | ids) + time.sleep(2) + return "requeue", "db_unavailable" + + # ---------- сама работа ---------- + + 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: + with telemetry.span("image.process", attributes={"messenger.image.content_type": lease.content_type, + "messenger.image.pixels": lease.width * lease.height}): + 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, + extra={"event": "staging.delete_deferred"}) + + # ---------- фоновые потоки ---------- + + 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, + extra={"event": "job.lease_not_renewed"}) + 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, + extra={"event": "job.lease_expired", "attachment_id": attachment_id}) + 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: + telemetry.setup("messenger-worker") + try: + Worker().run() + finally: + telemetry.shutdown() + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/student-tests/attachment_failover.py b/student-tests/attachment_failover.py new file mode 100644 index 0000000..d979d01 --- /dev/null +++ b/student-tests/attachment_failover.py @@ -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) diff --git a/student-tests/cache_revocation.py b/student-tests/cache_revocation.py new file mode 100644 index 0000000..681036c --- /dev/null +++ b/student-tests/cache_revocation.py @@ -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) diff --git a/student-tests/check_dashboard.py b/student-tests/check_dashboard.py new file mode 100644 index 0000000..1f0ae1a --- /dev/null +++ b/student-tests/check_dashboard.py @@ -0,0 +1,98 @@ +"""lab6, уровни 3–4: dashboard и источники данных импортируются из Git, а запросы панелей работают. + + make dashboard-check (= python student-tests/check_dashboard.py) + +1. Grafana (http://127.0.0.1:3000): здорова; источники prometheus, loki, tempo созданы provisioning + (а не руками) и проходят проверку подключения; dashboard messenger-lab6 импортирован из + infra/grafana/dashboards/messenger.json (тот же набор панелей), помечен как provisioned. +2. Каждый запрос каждой панели из JSON выполняется в своём хранилище без ошибок: PromQL — в + Prometheus, LogQL — в Loki, TraceQL — в Tempo. Пустой результат разрешён только у панелей, + которые показывают отказы (например, потери Collector при здоровом стенде), — они перечислены. +3. Alert rules загружены в Prometheus (HighErrorRate, QueueLagHigh, TelemetryExportFailing) и здоровы. +Выводится таблица «панель — единица — запрос» для REPORT.md. +GRAFANA_URL=none — пропустить шаг 1 (например, если проверяются только запросы). +""" +import json +import os + +import obs +from helpers import ROOT, check, run + +DASHBOARD = ROOT / "infra" / "grafana" / "dashboards" / "messenger.json" +# Эти запросы при здоровом стенде законно пусты: отказов нет. +MAY_BE_EMPTY = ("send_failed", "ALERTS", "outcome=\"ready\"", "time_to_ready", "4..", "5..") + + +def panels(dashboard): + for panel in dashboard["panels"]: + if panel.get("type") == "row": + continue + yield panel + + +def grafana_checks(dashboard): + health = obs.get_json(obs.GRAFANA_URL + "/api/health") + check(health.get("database") == "ok", f"grafana health: {health}") + sources = {ds["uid"]: ds for ds in obs.grafana("/api/datasources")} + for uid, kind in (("prometheus", "prometheus"), ("loki", "loki"), ("tempo", "tempo")): + check(uid in sources and sources[uid]["type"] == kind, f"datasource {uid} is not provisioned") + check(sources[uid].get("readOnly") is True, f"datasource {uid} must come from provisioning (readOnly)") + if uid == "tempo": + # Плагин Tempo в Grafana 12 не реализует /health через API (404 plugin.notImplemented): + # проверяем подключение настоящим запросом к Tempo через прокси Grafana. + check(isinstance(obs.grafana("/api/datasources/proxy/uid/tempo/api/search?limit=1"), dict), + "tempo datasource: search through Grafana failed") + continue + result = obs.grafana(f"/api/datasources/uid/{uid}/health") + check(result.get("status") == "OK", f"datasource {uid} health: {result}") + print("1. Grafana " + health.get("version", "?") + ": datasources prometheus, loki, tempo — provisioned " + "(readOnly); prometheus, loki health OK; tempo answers a search through Grafana") + imported = obs.grafana("/api/dashboards/uid/" + dashboard["uid"]) + check(imported["meta"].get("provisioned") is True, "dashboard must be provisioned from a file") + got = sorted(p["title"] for p in imported["dashboard"]["panels"]) + want = sorted(p["title"] for p in dashboard["panels"]) + check(got == want, "imported dashboard differs from infra/grafana/dashboards/messenger.json") + print(f" dashboard '{imported['dashboard']['title']}' provisioned from {imported['meta'].get('provisionedExternalId')}, " + f"{len(got)} panels (same as the JSON in Git)") + + +def main(): + dashboard = json.loads(DASHBOARD.read_text(encoding="utf-8")) + if os.environ.get("GRAFANA_URL", "") != "none": + grafana_checks(dashboard) + else: + print("1. Grafana checks skipped (GRAFANA_URL=none)") + + print("2. every panel query against its store:") + print(f" {'panel':<46} {'unit':<11} {'series':>6} query") + empty = [] + for panel in panels(dashboard): + unit = panel.get("fieldConfig", {}).get("defaults", {}).get("unit", "-") + for target in panel["targets"]: + kind = target["datasource"]["uid"] + if kind == "prometheus": + rows = obs.prom(target["expr"]) + query = target["expr"] + elif kind == "loki": + rows = obs.loki(target["expr"], minutes=60, limit=20) + query = target["expr"] + else: + rows = obs.tempo_search(target["query"], limit=5) + query = target["query"] + if not rows: + empty.append((panel["title"], query)) + print(f" {panel['title'][:46]:<46} {unit:<11} {len(rows):>6} {' '.join(query.split())[:150]}") + unexpected = [(title, q) for title, q in empty if not any(m in q for m in MAY_BE_EMPTY)] + check(not unexpected, f"queries without data: {unexpected}") + print(f" all queries succeeded; empty (allowed: failure-only panels): {len(empty)}") + + names = {r["name"]: r for r in obs.rules()} + for alert in ("HighErrorRate", "QueueLagHigh", "TelemetryExportFailing"): + check(alert in names and names[alert]["health"] == "ok", f"alert rule {alert} missing or unhealthy") + print("3. alert rules loaded and healthy: " + ", ".join(f"{n} ({names[n]['state']}, for {names[n].get('duration', 0)} s)" + for n in ("HighErrorRate", "QueueLagHigh", "TelemetryExportFailing"))) + print("PASS: provisioning from Git, every panel query returns data from Prometheus/Loki/Tempo, alert rules loaded") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/check_stack.py b/student-tests/check_stack.py new file mode 100644 index 0000000..2a2859e --- /dev/null +++ b/student-tests/check_stack.py @@ -0,0 +1,160 @@ +"""lab3–lab6, уровень 4: проверка устройства стенда по реальным контейнерам и docker compose config. + + make check-stack (= python student-tests/check_stack.py) + +- не меньше 2 работающих реплик api, у них нет опубликованных портов (обойти балансировщик нельзя); +- в балансировщике каждая реплика под проверкой готовности, резервных серверов без проверки нет + (неготовая реплика не получает запросы ни при каких условиях); +- ни у одного сервиса нет container_name (иначе нельзя запустить несколько реплик одного сервиса); +- наружу опубликованы только балансировщик и (с lab6) Grafana и Prometheus, и только на 127.0.0.1; +- у каждого работающего контейнера есть лимиты CPU и RAM; +- сети: postgres, valkey, s3, broker и worker только во внутренней сети backend, lb только в edge, api в обеих; +- (lab5) брокер — отдельный сервис с volume и постоянным hostname, без портов и без веб-консоли; + worker — отдельный сервис без портов; +- (lab6) otel-collector, prometheus, loki, tempo, grafana — отдельные сервисы с закреплёнными версиями; + хранилища телеметрии с volumes; OTLP, Loki и Tempo только во внутренней сети telemetry; +- секреты получает только тот, кому они нужны; +- версии 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") + allowed = ("lb", "grafana", "prometheus") + others = {service: ports for service, ports in published.items() if ports and service not in allowed} + check(not others, f"only lb, grafana and prometheus may publish ports, got {others}") + for service in allowed: + check(published.get(service) and all(b.startswith("127.0.0.1:") for b in published[service]), + f"{service} must be published on 127.0.0.1 only") + print("published: only lb, grafana (3000) and prometheus (9090), only on 127.0.0.1 (api replicas, OTLP, " + "Loki, Tempo 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")), + "stores and broker must be on backend only") + check(nets_of("worker") == ["backend", "telemetry"], "worker must be on backend + telemetry") + check(nets_of("lb") == ["edge", "telemetry"], "lb must be on edge (+ telemetry for its metrics)") + check(nets_of("api") == ["backend", "edge", "telemetry"], "api must be on edge, backend and telemetry") + check(networks.get("backend", {}).get("internal") is True, "backend network must be internal") + print("networks: lb -> edge (+telemetry); api -> edge + backend + telemetry; postgres, valkey, s3, broker -> " + "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") + + # lab6: наблюдаемость — отдельные сервисы общего стенда. + check(networks.get("telemetry", {}).get("internal") is True, "telemetry network must be internal") + for name in ("otel-collector", "loki", "tempo"): + check(nets_of(name) == ["telemetry"], f"{name} must be on the internal telemetry network only") + for name in ("prometheus", "grafana"): + check(nets_of(name) == ["ops", "telemetry"], f"{name}: telemetry + ops (for the 127.0.0.1 port only)") + for name in ("otel-collector", "prometheus", "loki", "tempo", "grafana"): + image = services[name]["image"] + check(":" in image and not image.endswith(":latest"), f"{name} image must be pinned") + running = compose_output("ps", "-q", name).split() + check(running, f"{name} is not running") + volumes = {"prometheus": "promdata", "loki": "lokidata", "tempo": "tempodata", "grafana": "grafanadata"} + for name, volume in volumes.items(): + check(any(v.get("source") == volume for v in services[name].get("volumes", [])), f"{name} needs volume {volume}") + check(services["worker"].get("environment", {}).get("OTEL_SERVICE_NAME") == "messenger-worker", + "worker must have its own service.name") + print("telemetry: " + "; ".join(f"{n} {services[n]['image']}" for n in + ("otel-collector", "prometheus", "loki", "tempo", "grafana"))) + print(" volumes promdata, lokidata, tempodata, grafanadata; OTLP/Loki/Tempo only on internal " + "network telemetry; worker service.name=messenger-worker") + + 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"], + "grafana": ["grafana_admin_password"], "otel-collector": [], "prometheus": [], "loki": [], + "tempo": []} + 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; collector and three " + "telemetry stores + Grafana pinned, with volumes, OTLP only on the internal network") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/check_telemetry.py b/student-tests/check_telemetry.py new file mode 100644 index 0000000..63b3ae9 --- /dev/null +++ b/student-tests/check_telemetry.py @@ -0,0 +1,183 @@ +"""lab6, уровни 3–4: сигналы своего приложения в хранилищах и связь запрос -> лог -> trace -> задание. + + make telemetry-check (= python student-tests/check_telemetry.py) + +1. Контролируемый HTTP-запрос (POST сообщения): по X-Request-Id ответа в Loki находится структурный + лог (event=http.request, severity, service.name, trace_id, span_id), по его trace_id в Tempo — + server span того же запроса (тот же request_id) с дочерними SQL-спанами. +2. Upload с одной внедрённой временной ошибкой worker (точка worker_transient): одна трасса + upload (SERVER) -> send (PRODUCER) -> process (CONSUMER, попытка 1, retry) -> jobs.retry -> + send (PRODUCER) -> process (CONSUMER, попытка 2, ready) -> S3 PutObject + SQL COMMIT результата. + Связь parent-child проверяется по span_id; логи worker по trace_id: job.retry и job.ready. +3. Метрики своего приложения: HTTP (метод, маршрут-шаблон, код), задания (тип, исход), + длительности (histogram), очередь, пул БД, насыщение worker, CPU/RAM процессов. + Ни у одной серии нет labels с ID (user/chat/message/attachment/request), маршрут — шаблон. +4. Запрещённые данные: текст сообщения, пароль и токен не находятся ни в логах (поиск по Loki), + ни в атрибутах спанов этих трасс; query-строки (filename) в спанах нет. +Токены и пароли в вывод не попадают: ищутся по значениям в памяти процесса. +""" +import re +import time +import uuid + +import obs +import ops +from filegen import wait_status +from helpers import Client, check, idempotency, run + +UUID = re.compile(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}") +FORBIDDEN_LABELS = {"user_id", "chat_id", "message_id", "attachment_id", "request_id", "url_path", "filename", + "messenger_attachment_id", "messenger_request_id", "messenger_job_id", "job_id", "trace_id"} + + +def child_of(spans, parent, **match): + return [s for s in spans if s["parent"] == parent["span_id"] + and all(s.get(k) == v or s["attrs"].get(k) == v for k, v in match.items())] + + +def controlled_request(api, alice, chat, marker): + response = api.call("POST", f"/api/v1/chats/{chat['id']}/messages", 201, actor=alice, headers=idempotency(), + body={"text": marker}, schema="Message") + request_id = response["headers"]["X-Request-Id"] + logs = obs.wait_logs(f'{{service_name="messenger-api"}} | request_id="{request_id}"') + entry = logs[-1]["labels"] + for field in ("service_name", "trace_id", "span_id", "event", "severity_text"): + check(entry.get(field), f"log for X-Request-Id has no {field}: {sorted(entry)}") + check(entry["event"] == "http.request", f"unexpected event {entry['event']}") + trace_id = entry["trace_id"] + spans = obs.tempo_trace(trace_id) + server = [s for s in spans if s["kind"] == "SERVER"] + check(len(server) == 1, f"expected one server span, got {len(server)}") + server = server[0] + check(server["attrs"].get("messenger.request_id") == request_id, "server span request_id differs from header") + check(server["attrs"].get("http.route") == "/api/v1/chats/{chat_id}/messages", "route template expected") + check(entry["span_id"] == server["span_id"], "log span_id must be the server span") + sql = [s for s in spans if s["kind"] == "CLIENT" and s["attrs"].get("db.system") == "postgresql"] + check(any(s["name"] == "INSERT" for s in sql), "no INSERT span under the request") + print(f"1. POST message: X-Request-Id={request_id} -> Loki: event={entry['event']} severity={entry['severity_text']} " + f"service={entry['service_name']} instance={entry.get('service_instance_id')} trace_id={trace_id} " + f"span_id={entry['span_id']}") + print(f" Tempo: trace {trace_id}, server span {server['span_id']} (request_id matches), {len(sql)} SQL spans:") + for line in obs.tree(spans): + print(" " + line) + return spans + + +def upload_chain(api, alice, bob, chat): + ops.arm("worker", "worker_transient", "1") + att, _content = api.attachment(alice, chat) + print(f"2. upload with one injected transient failure: attachment_id={att['id']} -> 202 queued") + ready = wait_status(api, bob, att["id"], ("ready",), seconds=90) + check(ready["status"] == "ready", "attachment must become ready after the retry") + + def complete(spans): + return sum(1 for s in spans if s["kind"] == "CONSUMER") >= 2 and \ + any(s["attrs"].get("messenger.job.outcome") == "ready" for s in spans) + + trace_id, spans = obs.wait_trace(f'{{ span.messenger.attachment.id = "{att["id"]}" && kind = server }}', complete, 90) + by_kind = {k: [s for s in spans if s["kind"] == k] for k in ("SERVER", "PRODUCER", "CONSUMER")} + upload = by_kind["SERVER"][0] + check(upload["service"] == "messenger-api" and upload["attrs"].get("http.response.status_code") == 202, + "upload server span expected") + send1 = child_of(spans, upload, kind="PRODUCER") + check(len(send1) == 1, "producer span must be a child of the upload span") + consume1 = child_of(spans, send1[0], kind="CONSUMER") + check(len(consume1) == 1 and consume1[0]["service"] == "messenger-worker", "consumer must be a child of producer") + consume1 = consume1[0] + check(consume1["attrs"].get("messenger.job.attempt") == 1 and consume1["attrs"].get("messenger.job.outcome") == "retry" + and consume1["status"] == "ERROR", "attempt 1 must be a failed (retry) consumer span") + retry = child_of(spans, consume1, name="jobs.retry") + check(len(retry) == 1, "jobs.retry span expected under attempt 1") + send2 = child_of(spans, retry[0], kind="PRODUCER") + check(len(send2) == 1 and send2[0]["attrs"].get("messenger.job.attempt") == 2, + "the retry message must be published as a child of jobs.retry") + consume2 = child_of(spans, send2[0], kind="CONSUMER") + check(len(consume2) == 1 and consume2[0]["attrs"].get("messenger.job.outcome") == "ready", "attempt 2 must be ready") + consume2 = consume2[0] + puts = [s for s in spans if s["attrs"].get("rpc.method") == "PutObject" and s["service"] == "messenger-worker"] + check(len(puts) >= 4, "original + 3 variants must be written to S3 in the trace") + completes = [s for s in spans if s["name"] == "jobs.complete" and s["parent"] == consume2["span_id"]] + check(completes and [s for s in spans if s["parent"] == completes[0]["span_id"] and s["name"] == "UPDATE"], + "COMMIT of the result (SQL UPDATE under jobs.complete) expected") + check({s["service"] for s in spans} == {"messenger-api", "messenger-worker"}, "both services must be in one trace") + print(f" one trace {trace_id}: SERVER -> PRODUCER -> CONSUMER(attempt 1, retry, ERROR) -> jobs.retry -> " + f"PRODUCER(attempt 2) -> CONSUMER(attempt 2, ready) -> {len(puts)} x S3 PutObject, SQL under jobs.complete") + for line in obs.tree([s for s in spans if not (s["kind"] == "CLIENT" and "rpc.method" not in s["attrs"])]): + print(" " + line) + worker_logs = obs.wait_logs(f'{{service_name="messenger-worker"}} | trace_id="{trace_id}"', count=2) + events = [e["labels"].get("event") for e in worker_logs] + check("job.retry" in events and "job.ready" in events, f"worker logs of the trace: {events}") + api_logs = obs.loki(f'{{service_name="messenger-api"}} | trace_id="{trace_id}"') + print(f" Loki by trace_id: worker events {events}; api events {[e['labels'].get('event') for e in api_logs]}") + return spans, att + + +def metrics_check(): + wanted = { + "HTTP requests (counter, method/route/code)": + 'sum by (http_request_method, http_route, http_response_status_code) ' + '(http_server_request_duration_seconds_count{job="messenger-api", http_route="/api/v1/chats/{chat_id}/messages"})', + "HTTP duration histogram buckets": 'count(http_server_request_duration_seconds_bucket{job="messenger-api"})', + "jobs processed by outcome": 'sum by (messenger_job_type, outcome) (messenger_jobs_processed_total)', + "job duration histogram": 'sum by (outcome) (messenger_job_duration_seconds_count)', + "time to ready histogram": 'sum(messenger_attachment_time_to_ready_seconds_count)', + "queue depth": 'max by (queue, state) (messenger_queue_depth)', + "oldest job age": 'max by (queue) (messenger_queue_oldest_age_seconds)', + "DB pool": 'sum by (job, db_client_connection_state) (db_client_connection_count)', + "worker busy/capacity": 'sum(messenger_worker_capacity)', + "process CPU": 'sum by (job) (process_cpu_time_seconds_total{job=~"messenger-.*"})', + "process RAM": 'sum by (job) (process_memory_usage_bytes{job=~"messenger-.*"})', + } + deadline = time.monotonic() + 40 # метрики уходят раз в 10 с + while True: + missing = [name for name, query in wanted.items() if not obs.prom(query)] + outcomes = {r["metric"].get("outcome") for r in obs.prom(wanted["jobs processed by outcome"])} + if not missing and {"ready", "retry"} <= outcomes: + break + check(time.monotonic() < deadline, f"metrics missing: {missing}, job outcomes {outcomes}") + time.sleep(3) + print("3. metrics of the application in Prometheus:") + for name, query in wanted.items(): + rows = obs.prom(query) + sample = ", ".join(f"{ {k: v for k, v in r['metric'].items()} }={r['value']:g}" for r in rows[:3]) + print(f" {name}: {len(rows)} series; {sample[:220]}") + series = obs.get_json(obs.PROM_URL + "/api/v1/series?match[]=" + + "%7Bjob%3D~%22messenger-.*%22%7D")["data"] + labels = set().union(*(s.keys() for s in series)) + check(not labels & FORBIDDEN_LABELS, f"forbidden labels in metrics: {labels & FORBIDDEN_LABELS}") + routes = {s.get("http_route") for s in series if s.get("http_route")} + check(not any(UUID.search(r) for r in routes), f"raw IDs in http_route: {routes}") + print(f" {len(series)} series of messenger-api/worker; label names: {', '.join(sorted(labels))}") + print(f" no ID labels; http_route values are templates: {', '.join(sorted(routes))}") + + +def forbidden_data(alice, marker, traces): + secrets = {"message text": marker, "password": alice["registration"]["password"], "session token": alice["token"]} + for what, value in secrets.items(): + found = obs.loki(f'{{service_name=~"messenger-api|messenger-worker"}} |= `{value}`', minutes=30) + check(not found, f"{what} found in logs") + for spans in traces: + for span in spans: + text = repr(span["attrs"]) + for what, value in secrets.items(): + check(value not in text, f"{what} found in span {span['name']}") + check("filename=" not in text and "Bearer" not in text and "authorization" not in text.lower(), + f"query string or auth header in span {span['name']}") + print("4. message text, password and session token: 0 hits in Loki (30 min) and in span attributes; " + "no query strings / Authorization in spans") + + +def main(): + api = Client(timeout=20) + alice, bob, _eve, chat = api.bootstrap() + marker = "секретный текст " + uuid.uuid4().hex + message_spans = controlled_request(api, alice, chat, marker) + upload_spans, _att = upload_chain(api, alice, bob, chat) + metrics_check() + forbidden_data(alice, marker, [message_spans, upload_spans]) + print("PASS: request -> log -> trace by X-Request-Id/trace_id; upload -> publish -> consume -> retry -> S3/DB in one " + "trace with parent-child links; app metrics without ID labels; no secrets or message bodies in telemetry") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/cleanup_race.py b/student-tests/cleanup_race.py new file mode 100644 index 0000000..3bb883b --- /dev/null +++ b/student-tests/cleanup_race.py @@ -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) diff --git a/student-tests/concurrency.py b/student-tests/concurrency.py new file mode 100644 index 0000000..68a26ae --- /dev/null +++ b/student-tests/concurrency.py @@ -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) diff --git a/student-tests/db/test_cleanup.py b/student-tests/db/test_cleanup.py new file mode 100644 index 0000000..fb94ab3 --- /dev/null +++ b/student-tests/db/test_cleanup.py @@ -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.assertIsNotNone(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) diff --git a/student-tests/db/test_jobs.py b/student-tests/db/test_jobs.py new file mode 100644 index 0000000..c7b2b43 --- /dev/null +++ b/student-tests/db/test_jobs.py @@ -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.assertIsNone(self.jobs.complete(stolen, self.variants())) # чужой жетон: не принимается + self.assertIsNotNone(self.jobs.complete(lease, self.variants())) + self.assertIsNone(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.assertIsNone(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) diff --git a/student-tests/db/test_store.py b/student-tests/db/test_store.py new file mode 100644 index 0000000..82a20e9 --- /dev/null +++ b/student-tests/db/test_store.py @@ -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() diff --git a/student-tests/db/test_trace_context.py b/student-tests/db/test_trace_context.py new file mode 100644 index 0000000..345bc32 --- /dev/null +++ b/student-tests/db/test_trace_context.py @@ -0,0 +1,102 @@ +"""lab6: контекст трассы в outbox (W3C traceparent) и время до ready — в настоящей PostgreSQL. + + make db-test == docker compose --profile tools run --rm db-test + +- задание, созданное внутри span (как при HTTP upload), пишет в outbox traceparent этого span, + и сообщение проходит проверку по contracts/jobs.schema.json; +- повтор без активного span (истёкший lease в фоновом потоке, replay оператора) копирует traceparent + прошлой строки: следующая попытка остаётся в той же трассе; +- повтор внутри span worker пишет traceparent этого span (новый родитель, тот же trace_id); +- complete() возвращает время от принятия загрузки до ready (секунды, >= 0), чужой lease — None. +SDK OpenTelemetry используется без экспорта (провайдер в памяти теста). +""" +import unittest +import uuid + +from opentelemetry.sdk.trace import TracerProvider + +from messenger import broker, config, db, jobs, telemetry +from messenger.store import PostgresStore + +TRACER = TracerProvider().get_tracer("db-test") + + +class TraceContextTest(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("tc_" + uuid.uuid4().hex[:12], "Trace test", "not-a-real-hash") + cls.chat = cls.store.create_chat(cls.user.id, "trace", [cls.user.id]) + + @classmethod + def tearDownClass(cls): + cls.pool.close() + + 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") + with self.pool.connection() as conn: + job_id = conn.execute("SELECT job_id FROM attachment_jobs WHERE attachment_id = %s", + (uuid.UUID(attachment_id),)).fetchone()[0] + return attachment_id, str(job_id) + + def outbox(self, job_id): + with self.pool.connection() as conn: + return [r[0] for r in conn.execute("SELECT payload FROM outbox WHERE job_id = %s ORDER BY id", + (uuid.UUID(job_id),)).fetchall()] + + def claim(self, payload): + decision = self.jobs.claim(broker.parse(broker.encode(payload)), "worker-test/1") + self.assertEqual(decision.kind, "claimed") + return decision.lease + + def test_upload_span_and_retries_stay_in_one_trace(self): + with TRACER.start_as_current_span("POST /attachments") as upload: + attachment_id, job_id = self.new_job() + trace_id = format(upload.get_span_context().trace_id, "032x") + span_id = format(upload.get_span_context().span_id, "016x") + first = self.outbox(job_id)[0] + # Флаги: 01 = sampled (SDK 1.45 добавляет бит random trace id, получается 03). + self.assertEqual(first["traceparent"][:-3], f"00-{trace_id}-{span_id}") + self.assertIn(first["traceparent"][-2:], ("01", "03")) + self.assertEqual(broker.parse(broker.encode(first))["traceparent"], first["traceparent"]) + + # Повтор без активного span (как reap в фоновом потоке): копия traceparent прошлой строки. + lease = self.claim(first) + self.assertEqual(self.jobs.retry(lease, "storage_unavailable", "test"), "retry") + second = self.outbox(job_id)[1] + self.assertEqual((second["attempt"], second["traceparent"]), (2, first["traceparent"])) + + # Повтор внутри span worker: новый родитель (span worker), та же трасса. + with self.pool.connection() as conn: + conn.execute("UPDATE attachment_jobs SET next_attempt_at = now() WHERE job_id = %s", (uuid.UUID(job_id),)) + lease = self.claim(second) + # Как в worker: consumer span — дочерний для traceparent из сообщения. + with TRACER.start_as_current_span("process attachments.process", context=telemetry.extract(second)) as consume: + self.assertEqual(self.jobs.retry(lease, "storage_unavailable", "test"), "retry") + third = self.outbox(job_id)[2] + self.assertEqual(third["traceparent"].split("-")[1], trace_id) + self.assertEqual(third["traceparent"].split("-")[2], format(consume.get_span_context().span_id, "016x")) + + def test_complete_returns_time_to_ready(self): + attachment_id, job_id = self.new_job() + lease = self.claim(self.outbox(job_id)[0]) + variants = [{"name": n, "storage_key": f"variants/{attachment_id}/{n}", "content_type": "image/jpeg", + "size_bytes": 5, "width": 1, "height": 1, "sha256": "a" * 64} + for n in ("thumbnail", "crop", "optimized")] + waited = self.jobs.complete(lease, variants) + self.assertIsInstance(waited, float) + self.assertGreaterEqual(waited, 0.0) + self.assertLess(waited, 60.0) + self.assertIsNone(self.jobs.complete(lease, variants)) # lease уже снят: результат не принимается + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/demo.py b/student-tests/demo.py new file mode 100644 index 0000000..fceef7d --- /dev/null +++ b/student-tests/demo.py @@ -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) diff --git a/student-tests/dependency_failure.py b/student-tests/dependency_failure.py new file mode 100644 index 0000000..c7b1a62 --- /dev/null +++ b/student-tests/dependency_failure.py @@ -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) diff --git a/student-tests/expiry.py b/student-tests/expiry.py new file mode 100644 index 0000000..9e022bd --- /dev/null +++ b/student-tests/expiry.py @@ -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) diff --git a/student-tests/failover_metrics.py b/student-tests/failover_metrics.py new file mode 100644 index 0000000..022ca4c --- /dev/null +++ b/student-tests/failover_metrics.py @@ -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) diff --git a/student-tests/failure_s3.py b/student-tests/failure_s3.py new file mode 100644 index 0000000..c9cbe66 --- /dev/null +++ b/student-tests/failure_s3.py @@ -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) diff --git a/student-tests/filegen.py b/student-tests/filegen.py new file mode 100644 index 0000000..37af896 --- /dev/null +++ b/student-tests/filegen.py @@ -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) diff --git a/student-tests/helpers.py b/student-tests/helpers.py new file mode 100644 index 0000000..e7c726d --- /dev/null +++ b/student-tests/helpers.py @@ -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 из корня репозитория; вывод скрыт (там могут быть имена/секреты).""" + 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) diff --git a/student-tests/incident_db.py b/student-tests/incident_db.py new file mode 100644 index 0000000..ecca252 --- /dev/null +++ b/student-tests/incident_db.py @@ -0,0 +1,188 @@ +"""lab6, уровень 4, инцидент 2: медленная / недоступная БД и чем она отличается от медленного обработчика. + + make incident-db (= python student-tests/incident_db.py) ~6 минут + make incident-db-down (= python student-tests/incident_db.py --down) ещё ~5 минут + +A. Медленный HTTP handler при здоровой БД (точка api_slow_handler = 1.5 с в обеих репликах): + трасса — server span ~1.5 с, а SQL-спаны внутри по миллисекунде («пустое» время — код обработчика); + метрики — растёт p95 маршрута, 5xx нет, пул БД свободен. +B. Медленная БД: отдельная сессия держит LOCK TABLE messages (как долгая миграция или забытая + транзакция). POST сообщения ждёт блокировку до statement_timeout (5 с) -> 503. Трасса — server span + ~5 с и SQL INSERT ~5 с со статусом ERROR; метрики — 5xx у приложения и на входе, заняты соединения пула. + Alert HighErrorRate -> firing; блокировка снята -> resolved. +C. (--down) БД недоступна: docker compose pause postgres. Реплики не проходят /health/ready, HAProxy сам + отвечает 503: 5xx есть только на входе, у приложения запросов нет совсем. HighErrorRate firing -> unpause -> resolved. +Выводы — для evidence/incident-db*.txt и REPORT.md. Токены не печатаются. +""" +import subprocess +import sys +import time + +import obs +import ops +from helpers import ROOT, Client, check, idempotency, run +from traffic import Traffic + +ROUTE = 'http_route="/api/v1/chats/{chat_id}/messages"' +P95_ROUTE = ('histogram_quantile(0.95, sum by (le) (rate(http_server_request_duration_seconds_bucket' + f'{{job="messenger-api",{ROUTE}}}[1m])))') +APP_5XX = ('sum(rate(http_server_request_duration_seconds_count{job="messenger-api",http_response_status_code=~"5.."}[1m]))' + ' or vector(0)') +APP_RPS = 'sum(rate(http_server_request_duration_seconds_count{job="messenger-api"}[1m])) or vector(0)' +EDGE = "messenger:edge_error_ratio:rate2m" +POOL_USED = 'sum(db_client_connection_count{db_client_connection_pool_name="messenger-api",db_client_connection_state="used"})' +POOL_WAIT = 'sum(db_client_connection_pending_requests{db_client_connection_pool_name="messenger-api"})' +READY = 'haproxy_backend_active_servers{proxy="api"}' +LOCK_TAG = "lab6-incident-db-lock" + + +def val(query): + v = obs.prom_value(query) + return "—" if v is None else f"{v:.3f}".rstrip("0").rstrip(".") + + +def snapshot(started, traffic): + state = obs.alerts().get("HighErrorRate", "inactive") + print(f" t={time.monotonic() - started:5.0f}s edge_5xx_ratio={val(EDGE):>6} app_5xx/s={val(APP_5XX):>6} " + f"app_rps={val(APP_RPS):>6} p95_messages={val(P95_ROUTE):>6}s pool_used={val(POOL_USED):>3} " + f"pool_waiting={val(POOL_WAIT):>3} ready_replicas={val(READY):>2} HighErrorRate={state:<8} http={traffic.snapshot()}") + return state + + +def wait_state(started, traffic, want, seconds): + deadline = time.monotonic() + seconds + while True: + state = snapshot(started, traffic) + if state in want: + return time.monotonic() - started + check(time.monotonic() < deadline, f"HighErrorRate {want} not reached in {seconds} s") + time.sleep(15) + + +def traced(api, actor, chat, expected): + """POST сообщения -> (код, X-Request-Id, trace_id, спаны) через лог в Loki.""" + response = api.call("POST", f"/api/v1/chats/{chat['id']}/messages", expected, actor=actor, + headers=idempotency(), body={"text": "диагностика"}) + request_id = response["headers"]["X-Request-Id"] + entry = obs.wait_logs(f'{{service_name="messenger-api"}} | request_id="{request_id}"')[-1]["labels"] + trace_id = entry["trace_id"] + time.sleep(4) + return response["status"], request_id, entry, trace_id, obs.tempo_trace(trace_id) + + +def describe(spans): + server = [s for s in spans if s["kind"] == "SERVER"][0] + sql = [s for s in spans if s["attrs"].get("db.system") == "postgresql"] + total = (server["end"] - server["start"]) / 1e6 + in_sql = sum((s["end"] - s["start"]) / 1e6 for s in sql) + slowest = max(sql, key=lambda s: s["end"] - s["start"]) if sql else None + return total, in_sql, slowest + + +def phase_slow_handler(api, alice, chat): + print("A. slow HTTP handler, healthy DB (fault api_slow_handler=1.5 s in every api replica)") + ops.arm("api", "api_slow_handler", "1.5") + try: + for _ in range(6): + api.message(alice, chat, "медленный обработчик") + status, request_id, entry, trace_id, spans = traced(api, alice, chat, 201) + finally: + ops.disarm("api", "api_slow_handler") + total, in_sql, slowest = describe(spans) + print(f" request {request_id} -> {status}; log event={entry['event']} severity={entry['severity_text']}; trace {trace_id}") + for line in obs.tree(spans): + print(" " + line) + time.sleep(12) + print(f" server span {total:.0f} ms, of it in SQL {in_sql:.1f} ms (slowest SQL {slowest['name']} " + f"{(slowest['end'] - slowest['start']) / 1e6:.1f} ms): the time is spent in the handler, not in the DB") + print(f" metrics: p95 POST messages = {val(P95_ROUTE)} s, app 5xx/s = {val(APP_5XX)}, pool waiting = {val(POOL_WAIT)}") + check(total > 1400 and in_sql < 300, "slow handler: long server span with short SQL spans expected") + return total, in_sql + + +def phase_slow_db(api, alice, bob, chat): + print("B. slow DB: a session holds LOCK TABLE messages; POST message waits until statement_timeout (5 s) -> 503") + check(obs.alerts().get("HighErrorRate") is None, "HighErrorRate must be inactive before the incident") + traffic = Traffic(api, bob, chat, threads=3, pause=0.2, timeout=20).start() + started = time.monotonic() + lock = None + try: + time.sleep(20) + snapshot(started, traffic) + sql = (f"/* {LOCK_TAG} */ BEGIN; LOCK TABLE messages IN ACCESS EXCLUSIVE MODE; SELECT pg_sleep(600); COMMIT;") + lock = subprocess.Popen(["docker", "compose", "exec", "-T", "postgres", "psql", "-X", "-q", "-U", "messenger", + "-d", "messenger", "-c", sql], cwd=ROOT, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + locked_at = time.monotonic() - started + print(f" t={locked_at:.0f}s lock taken") + time.sleep(8) + status, request_id, entry, trace_id, spans = traced(api, alice, chat, 503) + total, in_sql, slowest = describe(spans) + print(f" request {request_id} -> {status}; log event={entry['event']} severity={entry['severity_text']}; trace {trace_id}") + for line in obs.tree(spans): + print(" " + line) + print(f" server span {total:.0f} ms, of it in SQL {in_sql:.0f} ms; slowest SQL {slowest['name']} " + f"{(slowest['end'] - slowest['start']) / 1e6:.0f} ms status {slowest['status']}: the DB is slow") + check(slowest["status"] == "ERROR" and (slowest["end"] - slowest["start"]) / 1e6 > 4000, + "slow DB: a long SQL span with an error expected") + firing_at = wait_state(started, traffic, ("firing",), 300) + print(f" HighErrorRate FIRING at t={firing_at:.0f}s ({firing_at - locked_at:.0f} s after the lock)") + finally: + ops.psql(f"SELECT count(pg_cancel_backend(pid)) FROM pg_stat_activity WHERE query LIKE '%{LOCK_TAG}%' " + "AND pid <> pg_backend_pid()") + if lock is not None: + lock.wait(timeout=30) + released_at = time.monotonic() - started + print(f" t={released_at:.0f}s lock released (pg_cancel_backend)") + resolved_at = wait_state(started, traffic, ("inactive",), 300) + traffic.stop() + print(f" HighErrorRate RESOLVED at t={resolved_at:.0f}s ({resolved_at - released_at:.0f} s after the release); " + f"http codes: {traffic.snapshot()}") + return total, in_sql, firing_at - locked_at, resolved_at - released_at + + +def phase_db_down(api, bob, chat): + print("C. DB unavailable: docker compose pause postgres") + check(obs.alerts().get("HighErrorRate") is None, "HighErrorRate must be inactive before the incident") + traffic = Traffic(api, bob, chat, threads=3, pause=0.2, timeout=20).start() + started = time.monotonic() + try: + time.sleep(20) + snapshot(started, traffic) + ops.compose("pause", "postgres") + paused_at = time.monotonic() - started + print(f" t={paused_at:.0f}s postgres paused") + firing_at = wait_state(started, traffic, ("firing",), 300) + print(f" HighErrorRate FIRING at t={firing_at:.0f}s; ready replicas {val(READY)}, app requests/s {val(APP_RPS)}: " + "503 comes from HAProxy itself — no replica passes /health/ready (PostgreSQL)") + logs = obs.loki('{service_name="messenger-api"} | event="http.request" | http_route="/health/ready"', minutes=5) + print(f" logs: {len(logs)} failed /health/ready checks in 5 min, e.g. " + f"{logs[-1]['line'][:90] if logs else '—'}") + finally: + ops.compose("unpause", "postgres") + unpaused_at = time.monotonic() - started + print(f" t={unpaused_at:.0f}s postgres unpaused") + resolved_at = wait_state(started, traffic, ("inactive",), 300) + traffic.stop() + print(f" HighErrorRate RESOLVED at t={resolved_at:.0f}s ({resolved_at - unpaused_at:.0f} s after unpause); " + f"http codes: {traffic.snapshot()}") + + +def main(): + api = Client(timeout=20) + alice, bob, _eve, chat = api.bootstrap() + if "--down" in sys.argv: + phase_db_down(api, bob, chat) + print("PASS: DB unavailable -> 5xx only at the entry (HAProxy), HighErrorRate firing -> resolved") + return + handler_total, handler_sql = phase_slow_handler(api, alice, chat) + db_total, db_sql, fire, resolve = phase_slow_db(api, alice, bob, chat) + print("Summary: how to tell them apart") + print(f" slow handler: server span {handler_total:.0f} ms, SQL {handler_sql:.0f} ms, no 5xx, pool free") + print(f" slow DB: server span {db_total:.0f} ms, SQL {db_sql:.0f} ms (ERROR, statement timeout), 5xx, " + f"pool connections busy; HighErrorRate firing in {fire:.0f} s, resolved {resolve:.0f} s after the fix") + print("PASS: slow DB vs slow handler distinguished by trace (time in SQL spans) and metrics (5xx, pool); " + "HighErrorRate firing -> resolved") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/incident_worker.py b/student-tests/incident_worker.py new file mode 100644 index 0000000..d4ce64f --- /dev/null +++ b/student-tests/incident_worker.py @@ -0,0 +1,106 @@ +"""lab6, уровень 4, инцидент 1: worker остановлен -> растёт возраст задач -> QueueLagHigh firing -> resolved. + + make incident-worker (= python student-tests/incident_worker.py) + +Сценарий (около 5 минут): +1. фон: сообщения (3 потока) и загрузка картинки раз в 5 с; базовая линия метрик; +2. docker compose stop worker; загрузки продолжают получать 202, задания копятся; +3. каждые 15 с — снимок: глубина очереди, возраст старейшего задания, доставки worker в секунду, + состояние alert QueueLagHigh; ждём firing (порог 60 с, for 1m); +4. docker compose start worker; backlog уменьшается до 0, все загрузки — ready; ждём resolved; +5. диагностика «только по сохранённым наблюдениям»: что видно в метриках, логах и трассе одной + загрузки, сделанной во время отказа (разрыв между send и process). +Вывод — таймлайн для evidence/incident-worker.txt и REPORT.md. Токены не печатаются. +""" +import time + +import obs +import ops +from filegen import wait_status +from helpers import Client, check, run +from traffic import Traffic + +Q_DEPTH = 'max(messenger_queue_depth{job="messenger-api",state="ready"})' +Q_AGE = 'max(messenger_queue_oldest_age_seconds{job="messenger-api"})' +DELIVERIES = 'sum(rate(messenger_jobs_processed_total[1m]))' +BUSY = 'sum(messenger_worker_busy) / sum(messenger_worker_capacity)' + + +def snapshot(started, traffic, note=""): + def val(query): + v = obs.prom_value(query) + return "—" if v is None else f"{v:.2f}".rstrip("0").rstrip(".") + state = obs.alerts().get("QueueLagHigh", "inactive") + print(f" t={time.monotonic() - started:5.0f}s ready={val(Q_DEPTH):>4} oldest_age={val(Q_AGE):>6}s " + f"worker_deliveries/s={val(DELIVERIES):>5} worker_busy={val(BUSY):>4} QueueLagHigh={state:<8} " + f"http={traffic.snapshot()} {note}") + return state + + +def wait_state(started, traffic, predicate, seconds, what): + deadline = time.monotonic() + seconds + while True: + state = snapshot(started, traffic) + if predicate(state): + return time.monotonic() - started + check(time.monotonic() < deadline, f"{what} not reached in {seconds} s") + time.sleep(15) + + +def main(): + api = Client(timeout=20) + ops.wait_healthy("worker", 1) + alice, bob, _eve, chat = api.bootstrap() + check(obs.alerts().get("QueueLagHigh") is None, "QueueLagHigh must be inactive before the incident") + traffic = Traffic(api, alice, chat, threads=3, pause=0.3, uploads_every=5).start() + started = time.monotonic() + try: + print("1. baseline (worker running):") + time.sleep(15) + snapshot(started, traffic) + ops.stop("worker") + stopped_at = time.monotonic() - started + print(f"2. t={stopped_at:.0f}s docker compose stop worker; uploads continue") + pending_at = wait_state(started, traffic, lambda s: s in ("pending", "firing"), 240, "QueueLagHigh pending") + firing_at = wait_state(started, traffic, lambda s: s == "firing", 180, "QueueLagHigh firing") + print(f"3. QueueLagHigh pending at t={pending_at:.0f}s, FIRING at t={firing_at:.0f}s " + f"({firing_at - stopped_at:.0f} s after the worker stopped)") + during = list(traffic.uploads) + finally: + ops.start("worker") + started_at = time.monotonic() - started + print(f"4. t={started_at:.0f}s docker compose start worker") + ops.wait_healthy("worker", 1) + resolved_at = wait_state(started, traffic, lambda s: s == "inactive", 240, "QueueLagHigh resolved") + traffic.stop() + print(f" QueueLagHigh RESOLVED at t={resolved_at:.0f}s ({resolved_at - started_at:.0f} s after the worker started)") + uploads = traffic.uploads + for attachment_id, _ in uploads: + wait_status(api, bob, attachment_id, ("ready",), seconds=120) + print(f" all {len(uploads)} uploads of the run are ready (none lost); final http codes: {traffic.snapshot()}") + + # Диагностика по сохранённым наблюдениям. + print("5. diagnosis from stored telemetry:") + rows = obs.prom(f'max_over_time({Q_AGE}[10m:15s])') + print(f" metrics: max oldest_age over 10 min = {rows[0]['value']:.0f} s; worker deliveries/s fell to 0 " + "while API kept answering 2xx — the queue is not drained, the API is healthy") + stop_logs = obs.loki('{service_name="messenger-worker"} | event=~"worker.stopped|worker.started"', minutes=15) + print(" logs: " + "; ".join(f"{e['labels'].get('event')} ({e['labels'].get('service_instance_id')})" + for e in stop_logs[-4:])) + victim = during[len(during) // 2][0] if during else uploads[0][0] + trace_id, spans = obs.wait_trace(f'{{ span.messenger.attachment.id = "{victim}" && kind = server }}', + lambda s: any(x["attrs"].get("messenger.job.outcome") == "ready" for x in s), 90) + send = [s for s in spans if s["kind"] == "PRODUCER"][0] + consume = [s for s in spans if s["kind"] == "CONSUMER"][0] + gap = (consume["start"] - send["end"]) / 1e9 + print(f" trace {trace_id} of upload {victim} made during the outage: send -> process gap {gap:.0f} s " + f"(message waited in the queue), processing itself {(consume['end'] - consume['start']) / 1e9:.2f} s") + for line in obs.tree([s for s in spans if not (s["kind"] == "CLIENT" and "rpc.method" not in s["attrs"])]): + print(" " + line) + check(gap > 30, "the trace must show the waiting time in the queue") + print(f"PASS: worker stopped -> oldest job age grew -> QueueLagHigh firing in {firing_at - stopped_at:.0f} s; " + f"worker started -> backlog drained, alert resolved in {resolved_at - started_at:.0f} s; no uploads lost") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/lease_takeover.py b/student-tests/lease_takeover.py new file mode 100644 index 0000000..17fdebe --- /dev/null +++ b/student-tests/lease_takeover.py @@ -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) diff --git a/student-tests/load_profile.py b/student-tests/load_profile.py new file mode 100644 index 0000000..a2de9f6 --- /dev/null +++ b/student-tests/load_profile.py @@ -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) diff --git a/student-tests/loadgen.py b/student-tests/loadgen.py new file mode 100644 index 0000000..e1378c4 --- /dev/null +++ b/student-tests/loadgen.py @@ -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, + } diff --git a/student-tests/obs.py b/student-tests/obs.py new file mode 100644 index 0000000..0312c3d --- /dev/null +++ b/student-tests/obs.py @@ -0,0 +1,210 @@ +"""lab6: запросы к хранилищам телеметрии для собственных проверок (только стандартная библиотека). + +- Prometheus (метрики и alerts): http://127.0.0.1:9090 — опубликован только на 127.0.0.1; +- Loki (логи) и Tempo (трассы) наружу не опубликованы: запросы идут через Grafana + (http://127.0.0.1:3000, прокси источника данных /api/datasources/proxy/uid//...). + Пароль администратора Grafana читается из secrets/grafana_admin_password и не печатается. +Адреса можно переопределить: PROM_URL, GRAFANA_URL, LOKI_URL, TEMPO_URL (прямой адрес без Grafana). +""" +import base64 +import json +import os +import time +import urllib.error +import urllib.parse +import urllib.request + +from helpers import ROOT, check + +PROM_URL = os.environ.get("PROM_URL", "http://127.0.0.1:9090").rstrip("/") +GRAFANA_URL = os.environ.get("GRAFANA_URL", "http://127.0.0.1:3000").rstrip("/") +LOKI_URL = os.environ.get("LOKI_URL", "").rstrip("/") +TEMPO_URL = os.environ.get("TEMPO_URL", "").rstrip("/") + + +def _grafana_auth() -> str: + path = ROOT / "secrets" / "grafana_admin_password" + check(path.exists(), "secrets/grafana_admin_password not found: run sh scripts/init-secrets.sh") + password = path.read_text(encoding="utf-8").strip() + return "Basic " + base64.b64encode(f"admin:{password}".encode()).decode() + + +def get_json(url: str, auth: str | None = None, timeout: float = 15.0): + request = urllib.request.Request(url, headers={"Authorization": auth} if auth else {}) + try: + with urllib.request.urlopen(request, timeout=timeout) as response: + return json.loads(response.read() or b"null") + except urllib.error.HTTPError as exc: + body = exc.read()[:300].decode("utf-8", "replace") + raise RuntimeError(f"HTTP {exc.code} from {url.split('?')[0]}: {body}") from None + + +def grafana(path: str): + return get_json(GRAFANA_URL + path, _grafana_auth()) + + +def _via(direct: str, uid: str) -> tuple[str, str | None]: + if direct: + return direct, None + return f"{GRAFANA_URL}/api/datasources/proxy/uid/{uid}", _grafana_auth() + + +# ---------- Prometheus ---------- + +def prom(query: str, at: float | None = None) -> list[dict]: + """Instant query (сейчас или на момент at, unix-время) -> [{'metric': {...}, 'value': float}].""" + params = {"query": query} | ({"time": f"{at:.3f}"} if at else {}) + data = get_json(PROM_URL + "/api/v1/query?" + urllib.parse.urlencode(params)) + check(data["status"] == "success", f"prometheus: {data}") + result = data["data"]["result"] + if data["data"]["resultType"] == "scalar": + return [{"metric": {}, "value": float(result[1])}] + return [{"metric": r["metric"], "value": float(r["value"][1])} for r in result] + + +def prom_value(query: str, default: float | None = None, at: float | None = None) -> float | None: + rows = prom(query, at) + return rows[0]["value"] if rows else default + + +def alerts() -> dict: + """{alertname: 'pending'|'firing'} — активные alerts Prometheus.""" + data = get_json(PROM_URL + "/api/v1/alerts") + return {a["labels"]["alertname"]: a["state"] for a in data["data"]["alerts"]} + + +def rules() -> list[dict]: + data = get_json(PROM_URL + "/api/v1/rules") + return [r for g in data["data"]["groups"] for r in g["rules"]] + + +# ---------- Loki ---------- + +def loki(query: str, minutes: int = 15, limit: int = 200) -> list[dict]: + """Записи логов: [{'labels': {...}, 'line': str, 'ts': int}] (labels включают structured metadata).""" + base, auth = _via(LOKI_URL, "loki") + end = time.time_ns() + params = {"query": query, "limit": limit, "start": end - minutes * 60 * 10**9, "end": end, "direction": "backward"} + data = get_json(base + "/loki/api/v1/query_range?" + urllib.parse.urlencode(params), auth) + out = [] + for stream in data["data"]["result"]: + for ts, line in stream["values"]: + out.append({"labels": stream["stream"], "line": line, "ts": int(ts)}) + return sorted(out, key=lambda e: e["ts"]) + + +def wait_logs(query: str, count: int = 1, seconds: float = 60) -> list[dict]: + deadline = time.monotonic() + seconds + while True: + rows = loki(query) + if len(rows) >= count: + return rows + check(time.monotonic() < deadline, f"loki: no logs for {query}") + time.sleep(2) + + +# ---------- Tempo ---------- + +def tempo_search(traceql: str, limit: int = 20, minutes: int = 60) -> list[dict]: + base, auth = _via(TEMPO_URL, "tempo") + now = int(time.time()) + params = {"q": traceql, "limit": limit, "start": now - minutes * 60, "end": now + 60} + data = get_json(base + "/api/search?" + urllib.parse.urlencode(params), auth) + return data.get("traces", []) + + +def tempo_trace(trace_id: str) -> list[dict]: + """Все спаны трассы: [{'service', 'name', 'kind', 'span_id', 'parent', 'start', 'end', 'status', 'attrs'}].""" + base, auth = _via(TEMPO_URL, "tempo") + data = get_json(f"{base}/api/traces/{trace_id}", auth) + spans = [] + for batch in data.get("batches", data.get("resourceSpans", [])): + resource = {a["key"]: _value(a["value"]) for a in batch["resource"].get("attributes", [])} + for scope in batch.get("scopeSpans", []): + for s in scope["spans"]: + spans.append({ + "service": resource.get("service.name"), "instance": resource.get("service.instance.id"), + "name": s["name"], "kind": s.get("kind", "").replace("SPAN_KIND_", ""), + "span_id": _hex(s["spanId"]), "parent": _hex(s.get("parentSpanId", "")), + "start": int(s["startTimeUnixNano"]), "end": int(s["endTimeUnixNano"]), + "status": s.get("status", {}).get("code", "").replace("STATUS_CODE_", ""), + "attrs": {a["key"]: _value(a["value"]) for a in s.get("attributes", [])}, + }) + return sorted(spans, key=lambda sp: sp["start"]) + + +def wait_trace(traceql: str, predicate=lambda spans: True, seconds: float = 60) -> tuple[str, list[dict]]: + """Дождаться трассы по TraceQL, у которой выполняется predicate(спаны). Возвращает (trace_id, спаны).""" + deadline = time.monotonic() + seconds + while True: + for found in tempo_search(traceql): + spans = tempo_trace(found["traceID"]) + if spans and predicate(spans): + return _hex(found["traceID"]), spans + check(time.monotonic() < deadline, f"tempo: no complete trace for {traceql}") + time.sleep(3) + + +def _hex(value: str) -> str: + """Tempo отдаёт ID в hex (/api/traces) или base64 (часть версий): приводим к hex.""" + if not value: + return "" + if all(c in "0123456789abcdefABCDEF" for c in value) and len(value) in (16, 32): + return value.lower() + try: + return base64.b64decode(value).hex() + except ValueError: + return value + + +def _value(v: dict): + if "intValue" in v: + return int(v["intValue"]) # в JSON Tempo int64 приходит строкой + for key in ("stringValue", "doubleValue", "boolValue"): + if key in v: + return v[key] + return json.dumps(v) + + +def tree(spans: list[dict]) -> list[str]: + """Дерево трассы для evidence: отступ = вложенность, длительность в мс.""" + by_id = {s["span_id"]: s for s in spans} + children = {} + for s in spans: + parent = s["parent"] if s["parent"] in by_id else "" + children.setdefault(parent, []).append(s) + lines = [] + + def walk(span, depth): + keys = ("http.route", "http.response.status_code", "messenger.job.attempt", "messenger.job.outcome", + "messenger.job.error_code", "rpc.method") + extra = " ".join(f"{k.split('.')[-1]}={span['attrs'][k]}" for k in keys if k in span["attrs"]) + name = span["name"] if span["kind"] != "CLIENT" or "rpc.method" in span["attrs"] \ + else f"SQL {span['name']}" + lines.append(f"{' ' * depth}{span['service']:<17}{span['kind']:<9}{name[:48]:<48}" + f"{(span['end'] - span['start']) / 1e6:9.1f} ms {span['status'] or ''} {extra}".rstrip()) + for child in children.get(span["span_id"], []): + walk(child, depth + 1) + + for root in children.get("", []): + walk(root, 0) + return lines + + +def main(argv): + if argv[:1] == ["alerts"]: + for rule in rules(): + if rule.get("type") == "alerting": + print(f"{rule['name']:<24} {rule['state']:<9} for {rule.get('duration', 0):>4.0f} s health={rule['health']}") + elif argv[:1] == ["logs"]: + for entry in loki('{service_name=~"messenger-api|messenger-worker"} | severity_text=~"WARN.*|ERROR"', minutes=30, limit=30): + labels = entry["labels"] + print(f"{labels.get('service_name')} {labels.get('severity_text')} {labels.get('event')} " + f"trace_id={labels.get('trace_id', '-')} {entry['line'][:120]}") + else: + print("usage: python student-tests/obs.py alerts|logs") + + +if __name__ == "__main__": + import sys + main(sys.argv[1:]) diff --git a/student-tests/ops.py b/student-tests/ops.py new file mode 100644 index 0000000..ddc68d6 --- /dev/null +++ b/student-tests/ops.py @@ -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()") diff --git a/student-tests/outbox_crash.py b/student-tests/outbox_crash.py new file mode 100644 index 0000000..f3372a6 --- /dev/null +++ b/student-tests/outbox_crash.py @@ -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) diff --git a/student-tests/race.py b/student-tests/race.py new file mode 100644 index 0000000..866b64f --- /dev/null +++ b/student-tests/race.py @@ -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) diff --git a/student-tests/redelivery.py b/student-tests/redelivery.py new file mode 100644 index 0000000..4abef1d --- /dev/null +++ b/student-tests/redelivery.py @@ -0,0 +1,80 @@ +"""lab5, уровень 3: повторная доставка — нормальная ситуация, она не создаёт второй набор вариантов. + + make redelivery (= python student-tests/redelivery.py) + +1. upload -> ready: запоминаем варианты (SHA-256), объекты под variants// и строки в БД; +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) diff --git a/student-tests/report_tables.py b/student-tests/report_tables.py new file mode 100644 index 0000000..0c06a72 --- /dev/null +++ b/student-tests/report_tables.py @@ -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 +между метками и . Запускать после +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 = "", "" + + +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) diff --git a/student-tests/retry_replay.py b/student-tests/retry_replay.py new file mode 100644 index 0000000..4ee4e48 --- /dev/null +++ b/student-tests/retry_replay.py @@ -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) diff --git a/student-tests/rolling_update.py b/student-tests/rolling_update.py new file mode 100644 index 0000000..272f875 --- /dev/null +++ b/student-tests/rolling_update.py @@ -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) diff --git a/student-tests/run_failover.py b/student-tests/run_failover.py new file mode 100644 index 0000000..f030410 --- /dev/null +++ b/student-tests/run_failover.py @@ -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) diff --git a/student-tests/run_persistence.py b/student-tests/run_persistence.py new file mode 100644 index 0000000..ae30744 --- /dev/null +++ b/student-tests/run_persistence.py @@ -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) diff --git a/student-tests/s3_checks.py b/student-tests/s3_checks.py new file mode 100644 index 0000000..010d519 --- /dev/null +++ b/student-tests/s3_checks.py @@ -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/ -> originals/, " + "variants//v1/ (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) diff --git a/student-tests/staging_cleanup.py b/student-tests/staging_cleanup.py new file mode 100644 index 0000000..7509a31 --- /dev/null +++ b/student-tests/staging_cleanup.py @@ -0,0 +1,112 @@ +"""lab5, уровень 4: очистка staging после безопасной фиксации и уборка объектов без ссылок из БД. + + make staging-cleanup (= python student-tests/staging_cleanup.py) + +1. Обычный путь: после COMMIT результата worker сам удаляет staging/; остаются originals/ + и три варианта. +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) diff --git a/student-tests/stand.py b/student-tests/stand.py new file mode 100644 index 0000000..24e451c --- /dev/null +++ b/student-tests/stand.py @@ -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 ; возвращает 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 и его вывод (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()}") diff --git a/student-tests/telemetry_outage.py b/student-tests/telemetry_outage.py new file mode 100644 index 0000000..bd2782d --- /dev/null +++ b/student-tests/telemetry_outage.py @@ -0,0 +1,126 @@ +"""lab6, уровень 4, сценарий 3: хранилища телеметрии недоступны — API работает, память ограничена. + + make telemetry-outage (= python student-tests/telemetry_outage.py) ~7 минут + +1. фон: сообщения (3 потока) и загрузка картинки раз в 5 с; +2. docker compose stop tempo loki — на 3 минуты. Каждые 15 с: коды ответов API, RSS Collector, + очереди его exporter (пачки), неудачные отправки, состояние alert TelemetryExportFailing. + Ожидаем: все бизнес-запросы успешны, загрузки становятся ready, очередь растёт, но не выше ёмкости, + куча Collector ниже memory_limiter (400 МиБ), RSS ниже лимита контейнера (512 МиБ); +3. docker compose start tempo loki: очереди разгружаются, alert resolved. Данные, ждавшие в очереди + меньше 5 минут (retry max_elapsed_time), доезжают: трасса и лог загрузки, сделанной во время + отказа, находятся. Отброшенное (если очередь переполнилась) посчитано otelcol_exporter_send_failed_*; +4. docker compose stop otel-collector на 60 с: API работает (SDK отправляет в фоне и отбрасывает + не влезшее в очередь 2048 записей), RSS реплик API не растёт; после запуска телеметрия идёт снова. +""" +import time + +import obs +import ops +from filegen import wait_status +from helpers import Client, check, run +from traffic import Traffic + +RSS = 'max(otelcol_process_memory_rss_bytes)' +HEAP = 'max(otelcol_process_runtime_heap_alloc_bytes)' +QUEUE = 'sum by (exporter) (otelcol_exporter_queue_size)' +CAPACITY = 'max(otelcol_exporter_queue_capacity)' +FAILED = ('sum(otelcol_exporter_send_failed_spans_total) + sum(otelcol_exporter_send_failed_log_records_total)' + ' + sum(otelcol_exporter_send_failed_metric_points_total)') +API_RSS = 'max(process_memory_usage_bytes{job="messenger-api"})' +MIB = 2 ** 20 + + +def snapshot(started, traffic): + queues = {r["metric"].get("exporter", "?").split("/")[-1]: int(r["value"]) for r in obs.prom(QUEUE)} + rss, heap = obs.prom_value(RSS, 0) / MIB, obs.prom_value(HEAP, 0) / MIB + state = obs.alerts().get("TelemetryExportFailing", "inactive") + print(f" t={time.monotonic() - started:5.0f}s collector heap={heap:5.1f} rss={rss:6.1f} MiB queues={queues} " + f"send_failed_total={obs.prom_value(FAILED, 0):.0f} TelemetryExportFailing={state:<8} http={traffic.snapshot()}") + return max(rss, 0), heap, queues, state + + +def main(): + api = Client(timeout=20) + alice, bob, _eve, chat = api.bootstrap() + traffic = Traffic(api, alice, chat, threads=3, pause=0.3, uploads_every=5).start() + started = time.monotonic() + capacity = obs.prom_value(CAPACITY, 0) + failed_before = obs.prom_value(FAILED, 0) + max_rss, max_heap, max_queue = 0.0, 0.0, 0 + try: + time.sleep(15) + print(f"1. baseline (exporter queue capacity {capacity:.0f} batches, memory_limiter 400 MiB heap, " + "container limit 512 MiB):") + snapshot(started, traffic) + ops.stop("tempo", "loki") + stopped_at = time.monotonic() - started + print(f"2. t={stopped_at:.0f}s docker compose stop tempo loki (traces and logs stores)") + firing = None + while time.monotonic() - started - stopped_at < 180: + time.sleep(15) + rss, heap, queues, state = snapshot(started, traffic) + max_rss, max_heap = max(max_rss, rss), max(max_heap, heap) + max_queue = max([max_queue] + list(queues.values())) + if state == "firing" and firing is None: + firing = time.monotonic() - started + during = list(traffic.uploads) + check(during, "no uploads during the outage") + victim = during[-3][0] + ready = wait_status(api, alice, victim, ("ready",), seconds=60) + print(f" upload {victim} made during the outage -> {ready['status']} (business path unaffected)") + codes = traffic.snapshot() + bad = {k: v for k, v in codes.items() if not k.endswith(("201", "202"))} + check(not bad, f"business requests failed during the telemetry outage: {bad}") + check(max_heap < 400, f"collector heap {max_heap:.0f} MiB exceeded memory_limiter") + check(max_rss < 512, f"collector RSS {max_rss:.0f} MiB above the container limit") + check(max_queue <= capacity, "exporter queue above its capacity") + alert = f"firing at t={firing:.0f}s" if firing else "not firing yet" + print(f" during the outage: every business request succeeded {codes}; collector RSS max {max_rss:.0f} MiB " + f"(heap max {max_heap:.0f} MiB < 400 MiB limit); exporter queue max {max_queue} of {capacity:.0f} batches; " + f"TelemetryExportFailing {alert}") + finally: + ops.start("tempo", "loki") + started_at = time.monotonic() - started + print(f"3. t={started_at:.0f}s docker compose start tempo loki") + deadline = time.monotonic() + 300 + while True: + time.sleep(15) + _rss, _heap, queues, state = snapshot(started, traffic) + if not any(queues.values()) and state == "inactive": + break + check(time.monotonic() < deadline, "queues did not drain / alert did not resolve") + print(f" queues drained and TelemetryExportFailing resolved at t={time.monotonic() - started:.0f}s") + lost = obs.prom_value(FAILED, 0) - failed_before + attachment_id, request_id = during[len(during) // 2] + logs = obs.wait_logs(f'{{service_name="messenger-api"}} | request_id="{request_id}"', seconds=120) + trace_id, _spans = obs.wait_trace(f'{{ span.messenger.attachment.id = "{attachment_id}" && kind = server }}', + seconds=120) + print(f" upload {attachment_id} from the middle of the outage: log (X-Request-Id {request_id}) and trace " + f"{trace_id} arrived after recovery (they waited in the collector queue); " + f"telemetry items dropped by exporters during the run: {lost:.0f}") + + print("4. docker compose stop otel-collector for 60 s (the SDK cannot export at all)") + api_rss_before = obs.prom_value(API_RSS, 0) / MIB + before = traffic.snapshot() + ops.stop("otel-collector") + try: + time.sleep(60) + finally: + ops.start("otel-collector") + after = traffic.snapshot() + delta = {k: after.get(k, 0) - before.get(k, 0) for k in after} + bad = {k: v for k, v in delta.items() if v and not k.endswith(("201", "202"))} + check(not bad, f"business requests failed while the collector was down: {bad}") + time.sleep(30) + traffic.stop() + api_rss_after = obs.prom_value(API_RSS, 0) / MIB + print(f" API answered {delta} while the collector was down (no errors); API replica RSS " + f"{api_rss_before:.0f} -> {api_rss_after:.0f} MiB (SDK queues are bounded: 2048 records per signal)") + check(api_rss_after < api_rss_before + 60, "API memory grew while the collector was down") + print("PASS: telemetry stores and the collector down -> business API unaffected, bounded collector memory and " + "queues, delayed telemetry delivered after recovery, drops are counted") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/telemetry_persistence.py b/student-tests/telemetry_persistence.py new file mode 100644 index 0000000..fde238b --- /dev/null +++ b/student-tests/telemetry_persistence.py @@ -0,0 +1,68 @@ +"""lab6, уровень 3: persistent volumes хранилищ телеметрии сохраняют историю после перезапуска. + + make telemetry-persistence (= python student-tests/telemetry_persistence.py) + +До перезапуска запоминаются: трасса последней загрузки (Tempo), лог запроса по X-Request-Id (Loki), +значение HTTP-счётчика на момент 2 минуты назад (Prometheus). Затем +docker compose restart prometheus loki tempo grafana (те же контейнеры и volumes promdata, +lokidata, tempodata, grafanadata) — и те же данные находятся снова, dashboard по-прежнему импортирован. +""" +import time + +import obs +import ops +from helpers import Client, check, idempotency, run + +COUNTER = 'sum(http_server_request_duration_seconds_count{job="messenger-api"})' + + +def wait_up(seconds=180): + deadline = time.monotonic() + seconds + while True: + try: + obs.prom("up") + obs.loki('{service_name="messenger-api"}', minutes=1, limit=1) + obs.tempo_search("{ kind = server }", limit=1, minutes=5) + return + except Exception: # хранилища ещё стартуют + check(time.monotonic() < deadline, "telemetry stores did not come back") + time.sleep(3) + + +def main(): + api = Client(timeout=20) + alice, _bob, _eve, chat = api.bootstrap() + att, _ = api.attachment(alice, chat) + response = api.call("POST", f"/api/v1/chats/{chat['id']}/messages", 201, actor=alice, headers=idempotency(), + body={"text": "до перезапуска хранилищ"}) + request_id = response["headers"]["X-Request-Id"] + log_before = obs.wait_logs(f'{{service_name="messenger-api"}} | request_id="{request_id}"')[-1] + trace_id, spans = obs.wait_trace(f'{{ span.messenger.attachment.id = "{att["id"]}" && kind = server }}') + at = time.time() - 120 + counter_before = obs.prom_value(COUNTER, at=at) + check(counter_before is not None, "no HTTP counter 2 minutes ago: run make test first and wait 2 minutes") + print(f"before: trace {trace_id} ({len(spans)} spans), log of X-Request-Id {request_id}, " + f"HTTP requests counter at t-120s = {counter_before:.0f}") + + ops.restart("prometheus", "loki", "tempo", "grafana") + print("docker compose restart prometheus loki tempo grafana (same containers, volumes kept)") + wait_up() + + spans_after = obs.tempo_trace(trace_id) + check(len(spans_after) == len(spans), f"trace changed after restart: {len(spans)} -> {len(spans_after)} spans") + log_after = obs.wait_logs(f'{{service_name="messenger-api"}} | request_id="{request_id}"', seconds=90)[-1] + check(log_after["line"] == log_before["line"], "log line changed after restart") + counter_after = obs.prom_value(COUNTER, at=at) + check(counter_after == counter_before, f"metric history changed: {counter_before} -> {counter_after}") + print(f"after: trace {trace_id} — {len(spans_after)} spans; log found; counter at the same past moment " + f"= {counter_after:.0f}") + try: + dashboard = obs.grafana("/api/dashboards/uid/messenger-lab6") + print(f" Grafana: dashboard '{dashboard['dashboard']['title']}' still provisioned") + except Exception as exc: # без Grafana (например, проверка только хранилищ) — не ошибка этой проверки + print(f" Grafana not checked: {type(exc).__name__}") + print("PASS: Prometheus, Loki and Tempo keep their history in volumes across a restart") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 0000000..aa62ec9 --- /dev/null +++ b/student-tests/test_api.py @@ -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() diff --git a/student-tests/test_attachments.py b/student-tests/test_attachments.py new file mode 100644 index 0000000..ad2a3e3 --- /dev/null +++ b/student-tests/test_attachments.py @@ -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"tail", "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"", "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", "..", + "photo‮gnp.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) diff --git a/student-tests/test_auth.py b/student-tests/test_auth.py new file mode 100644 index 0000000..3928cf7 --- /dev/null +++ b/student-tests/test_auth.py @@ -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() diff --git a/student-tests/test_balancing.py b/student-tests/test_balancing.py new file mode 100644 index 0000000..78899dc --- /dev/null +++ b/student-tests/test_balancing.py @@ -0,0 +1,85 @@ +"""lab3: несколько реплик API за балансировщиком и общее состояние. + +Запуск при запущенном стенде: make balancing (или вместе со всеми: make student-test). +Все запросы идут на BASE_URL = балансировщик HAProxy (127.0.0.1:8080). + +1. Один токен обслуживают разные реплики (X-Instance-Id), повторный вход не нужен: + сессии в общем PostgreSQL + кэш в общем Valkey, а не в памяти реплики. +2. Записал через одну реплику — сразу читаешь через другую: данные в общем PostgreSQL. +3. Logout через одну реплику действует на всех. +4. X-Instance-Id есть в каждом ответе (и в ошибках, и в health) и совпадает с ID + настоящего запущенного контейнера api: заголовок — не выдумка, это разные процессы. +5. Кэш сессий общий: запись, положенную одной репликой, используют все (промахов кэша нет). +""" +import unittest +from collections import Counter + +from helpers import Client, idempotency +from stand import api_containers, valkey_stats + + +class BalancingTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.api = Client() + cls.alice, cls.bob, cls.eve, cls.chat = cls.api.bootstrap() + + def me(self, actor, expected=200): + reply = self.api.call("GET", "/api/v1/users/me", expected, actor=actor, + schema="User" if expected == 200 else None) + return reply["headers"]["X-Instance-Id"], reply["json"] + + def test_one_session_is_served_by_every_replica(self): + replies = [self.me(self.alice) for _ in range(20)] + served = Counter(instance for instance, _ in replies) + self.assertTrue(all(user["id"] == self.alice["id"] for _, user in replies), "another user returned") + self.assertGreaterEqual(len(served), 2, "all requests went to one replica: balancing does not work") + running = api_containers() + for instance in served: + self.assertTrue(any(container.startswith(instance) for container in running), + f"X-Instance-Id {instance} is not a running api container") + print(f"\n 20 x GET /users/me с одним токеном -> реплики {dict(served)}; " + f"это ID запущенных контейнеров api, повторный вход не нужен") + + def test_write_on_one_replica_read_on_another(self): + sent = self.api.message(self.alice, self.chat, "записано через одну реплику") + writer = sent["headers"]["X-Instance-Id"] + readers = set() + for _ in range(6): + page = self.api.call("GET", f"/api/v1/chats/{self.chat['id']}/messages?limit=100", + actor=self.bob, schema="MessagePage") + self.assertIn(sent["json"], page["json"]["items"], "confirmed message is not visible") + readers.add(page["headers"]["X-Instance-Id"]) + self.assertTrue(readers - {writer}, "no read went to another replica") + print(f"\n сообщение записала реплика {writer}, сразу прочитали {sorted(readers)}") + + def test_logout_applies_on_every_replica(self): + carol = self.api.user("carol") + self.api.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=carol) + after = [self.me(carol, expected=401)[0] for _ in range(6)] + self.assertGreaterEqual(len(set(after)), 2, "401 came from one replica only") + print(f"\n logout через одну реплику -> 401 на {sorted(set(after))}") + + def test_instance_id_on_errors_and_health(self): + # Клиент курса сам проверяет X-Request-Id и X-Instance-Id у каждого ответа. + self.api.call("GET", "/health/live", schema="Health") + self.api.call("GET", "/health/ready", schema="Health") + self.api.call("GET", "/api/v1/no-such-path", 404, actor=self.alice) + self.api.call("GET", "/api/v1/users/me", 401) + self.api.call("POST", f"/api/v1/chats/{self.chat['id']}/messages", 400, actor=self.alice, + body={"text": ""}, headers=idempotency()) + print("\n X-Instance-Id есть в health, 404, 401 и 400") + + def test_session_cache_is_shared_between_replicas(self): + dave = self.api.user("dave") # вход уже положил запись о сессии в общий Valkey + hits_before, misses_before = valkey_stats() + served = Counter(self.me(dave)[0] for _ in range(10)) + hits_after, misses_after = valkey_stats() + self.assertGreaterEqual(len(served), 2, "requests did not reach both replicas") + self.assertEqual(misses_after - misses_before, 0, "cache miss: a replica did not use the shared entry") + print(f"\n 10 x GET /users/me через реплики {dict(served)}: попаданий в кэш " + f"+{hits_after - hits_before}, промахов +{misses_after - misses_before} — кэш общий") + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/test_idempotency.py b/student-tests/test_idempotency.py new file mode 100644 index 0000000..b1b3f9e --- /dev/null +++ b/student-tests/test_idempotency.py @@ -0,0 +1,159 @@ +"""lab3: Idempotency-Key у POST /chats/{id}/messages. + +Запуск при запущенном стенде: make idempotency (или вместе со всеми: make student-test). +Все запросы идут через балансировщик, поэтому повторы попадают на разные реплики. + +- повтор того же запроса (в том числе через другую реплику) -> тот же 201 и то же сообщение; +- 20 одновременных запросов с одним ключом через обе реплики -> ровно одно сообщение; +- одновременные разные тела с одним ключом -> одно сообщение, остальным 409; +- форматирование JSON не важно; другое тело с тем же ключом -> 409; +- область ключа: пользователь + чат (тот же ключ у другого пользователя или в другом чате независим); +- нет ключа или он неверный -> 400; ошибка 400 ключ не «занимает»; +- повтор заново проверяет сессию (401 после logout) и доступ к чату (404 постороннему). +""" +import threading +import unittest +import uuid +from collections import Counter +from concurrent.futures import ThreadPoolExecutor + +from helpers import Client, idempotency, login, read_history + +PARALLEL = 20 + + +class IdempotencyTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.api = Client() + cls.alice, cls.bob, cls.eve, cls.chat = cls.api.bootstrap() + + def path(self, chat=None): + return f"/api/v1/chats/{(chat or self.chat)['id']}/messages" + + def post(self, actor, text, key, expected=201, chat=None, api=None): + return (api or self.api).call("POST", self.path(chat), expected, actor=actor, body={"text": text}, + headers=idempotency(key), schema="Message" if expected == 201 else None) + + def count_text(self, text, chat=None): + history, _ = read_history(self.api, self.alice, (chat or self.chat)["id"]) + return sum(1 for message in history if message["text"] == text) + + def test_replay_through_another_replica_returns_same_message(self): + key, text = uuid.uuid4().hex, "повтор " + uuid.uuid4().hex + first = self.post(self.alice, text, key) + replies = [self.post(self.alice, text, key) for _ in range(4)] + self.assertTrue(all(reply["json"] == first["json"] for reply in replies), "replay differs") + instances = {first["headers"]["X-Instance-Id"]} | {r["headers"]["X-Instance-Id"] for r in replies} + self.assertGreaterEqual(len(instances), 2, "replays did not switch replica") + self.assertEqual(self.count_text(text), 1) + print(f"\n 1 запрос + 4 повтора через реплики {sorted(instances)}: 201 и то же сообщение, в истории 1") + + def test_parallel_same_key_through_replicas_creates_one_message(self): + key, text = uuid.uuid4().hex, "параллельно " + uuid.uuid4().hex + start = threading.Barrier(PARALLEL) + + def send(_): + client = Client() # у каждого «клиента» свои соединения + start.wait() + return self.post(self.alice, text, key, api=client) + + with ThreadPoolExecutor(max_workers=PARALLEL) as pool: + replies = list(pool.map(send, range(PARALLEL))) + ids = {reply["json"]["id"] for reply in replies} + instances = Counter(reply["headers"]["X-Instance-Id"] for reply in replies) + self.assertEqual(len(ids), 1, "different messages for one key") + self.assertGreaterEqual(len(instances), 2, "parallel requests did not reach both replicas") + self.assertEqual(self.count_text(text), 1, "duplicate message created") + print(f"\n {PARALLEL} одновременных POST с одним ключом через реплики {dict(instances)}: " + f"все 201 с одним id, в истории 1 сообщение") + + def test_parallel_different_bodies_same_key(self): + key = uuid.uuid4().hex + texts = [f"тело {n} {key}" for n in range(10)] + start = threading.Barrier(len(texts)) + + def send(text): + client = Client() + start.wait() + reply = client.call("POST", self.path(), [201, 409], actor=self.alice, body={"text": text}, + headers=idempotency(key)) + return text, reply["status"], reply["json"] + + with ThreadPoolExecutor(max_workers=len(texts)) as pool: + results = list(pool.map(send, texts)) + created = [text for text, status, _ in results if status == 201] + self.assertEqual(len(created), 1, f"expected exactly one 201, got {len(created)}") + self.assertEqual(sum(1 for _, status, _ in results if status == 409), len(texts) - 1) + self.assertEqual(sum(self.count_text(text) for text in texts), 1) + print(f"\n {len(texts)} одновременных разных тел с одним ключом: 201 x1, 409 x{len(texts) - 1}, " + f"в истории 1 сообщение") + + def test_json_formatting_does_not_matter(self): + key, text = uuid.uuid4().hex, "формат " + uuid.uuid4().hex + first = self.post(self.alice, text, key)["json"] + for raw in (('{ "text" : "%s" }' % text).encode("utf-8"), ('{\n "text": "%s"\n}' % text).encode("utf-8")): + again = self.api.call("POST", self.path(), 201, actor=self.alice, raw=raw, schema="Message", + headers={"Content-Type": "application/json", **idempotency(key)})["json"] + self.assertEqual(again, first) + print("\n тот же JSON с другими пробелами и переносами -> тот же 201 и то же сообщение") + + def test_same_key_other_body_is_409(self): + key, text = uuid.uuid4().hex, "оригинал " + uuid.uuid4().hex + self.post(self.alice, text, key) + error = self.post(self.alice, text + " (изменено)", key, expected=409)["json"]["error"] + self.assertEqual(error["code"], "conflict") + self.assertEqual(self.count_text(text), 1) + self.assertEqual(self.count_text(text + " (изменено)"), 0) + print("\n другой текст с тем же ключом -> 409 conflict, второе сообщение не создано") + + def test_key_scope_is_user_and_chat(self): + key, text = uuid.uuid4().hex, "область " + uuid.uuid4().hex + other_chat = self.api.call("POST", "/api/v1/chats", 201, actor=self.alice, schema="Chat", + body={"title": "второй чат", "member_ids": [self.alice["id"], self.bob["id"]]})["json"] + by_alice = self.post(self.alice, text, key)["json"] + by_bob = self.post(self.bob, text, key)["json"] + in_other_chat = self.post(self.alice, text, key, chat=other_chat)["json"] + self.assertEqual(len({by_alice["id"], by_bob["id"], in_other_chat["id"]}), 3) + print("\n тот же ключ у другого пользователя и в другом чате -> независимые сообщения") + + def test_key_is_required_and_validated(self): + text = "без ключа " + uuid.uuid4().hex + self.api.call("POST", self.path(), 400, actor=self.alice, body={"text": text}) + for bad in ("", "a" * 129, "пробел есть", "a b", "slash/no", "ключ"): + # Не-ASCII отправляем как есть, байтами UTF-8 (так их пришлёт реальный клиент). + header = bad.encode("utf-8").decode("latin-1") + self.api.call("POST", self.path(), 400, actor=self.alice, body={"text": text}, + headers={"Idempotency-Key": header}) + self.post(self.alice, text + " 128", "k" * 128) + self.post(self.alice, text + " punct", "Az09._:-" + uuid.uuid4().hex) + self.assertEqual(self.count_text(text), 0) + print("\n нет ключа, пустой, 129 символов, пробел, '/', кириллица -> 400; 128 символов и ._:- -> 201") + + def test_failed_request_does_not_burn_key(self): + key, text = uuid.uuid4().hex, "после ошибки " + uuid.uuid4().hex + self.post(self.alice, " ", key, expected=400) # пустой текст: 400, ничего не сохранено + created = self.post(self.alice, text, key)["json"] + self.assertEqual(created["text"], text) + print("\n с тем же ключом: сначала 400 (пустой текст), потом 201 — ошибка ключ не заняла") + + def test_replay_rechecks_session_and_access(self): + key, text = uuid.uuid4().hex, "проверка доступа " + uuid.uuid4().hex + frank = self.api.user("frank") + chat = self.api.call("POST", "/api/v1/chats", 201, actor=frank, schema="Chat", + body={"title": "frank", "member_ids": [frank["id"], self.bob["id"]]})["json"] + first = self.post(frank, text, key, chat=chat)["json"] + self.post(self.eve, text, key, expected=404, chat=chat) # посторонний: 404, а не сохранённый ответ + token = frank["token"] + self.api.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=frank) + self.post(frank, text, key, expected=401, chat=chat) # отозванный токен: 401 + session = login(self.api, frank["registration"]["username"], frank["registration"]["password"]) + frank_again = dict(frank, token=session["token"]) # новый вход, новый токен + self.assertNotEqual(frank_again["token"], token) + again = self.post(frank_again, text, key, chat=chat)["json"] + self.assertEqual(again, first) + print("\n повтор: посторонний -> 404, после logout -> 401, после нового входа -> то же сообщение") + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/traffic.py b/student-tests/traffic.py new file mode 100644 index 0000000..fc8b0ef --- /dev/null +++ b/student-tests/traffic.py @@ -0,0 +1,73 @@ +"""lab6: фоновая нагрузка для инцидентов — несколько потоков пишут сообщения (и по желанию грузят картинки). + +Нагрузка честная для наблюдения: ошибки не повторяются прозрачно, каждый ответ (код или таймаут) +считается. Токены живут только в памяти и не печатаются. +""" +import json +import threading +import time +import urllib.error +import urllib.request +import uuid +from collections import Counter + +from helpers import ROOT, Client + +SAMPLE = (ROOT / "tests" / "fixtures" / "sample.png").read_bytes() + + +class Traffic: + def __init__(self, api: Client, actor: dict, chat: dict, threads: int = 3, pause: float = 0.2, + uploads_every: float = 0.0, timeout: float = 15.0): + self.base, self.token, self.chat = api.base, actor["token"], chat["id"] + self.threads, self.pause, self.uploads_every, self.timeout = threads, pause, uploads_every, timeout + self.stop_event = threading.Event() + self.lock = threading.Lock() + self.codes = Counter() + self.uploads = [] # (attachment_id, X-Request-Id) + self._workers = [] + + def _request(self, method, path, data, headers): + headers = dict(headers, Authorization="Bearer " + self.token) + request = urllib.request.Request(self.base + path, data=data, method=method, headers=headers) + try: + with urllib.request.urlopen(request, timeout=self.timeout) as response: + return response.status, response.read(), response.headers + except urllib.error.HTTPError as exc: + return exc.code, exc.read(), exc.headers + except (urllib.error.URLError, TimeoutError, OSError): + return "timeout", b"", {} + + def _loop(self, number): + last_upload = time.monotonic() + while not self.stop_event.is_set(): + body = json.dumps({"text": f"нагрузка {number} {uuid.uuid4().hex[:6]}"}).encode() + status, _, _ = self._request("POST", f"/api/v1/chats/{self.chat}/messages", body, + {"Content-Type": "application/json", "Idempotency-Key": uuid.uuid4().hex}) + with self.lock: + self.codes[str(status)] += 1 + if number == 0 and self.uploads_every and time.monotonic() - last_upload >= self.uploads_every: + last_upload = time.monotonic() + status, raw, headers = self._request("POST", f"/api/v1/chats/{self.chat}/attachments?filename=load.png", + SAMPLE, {"Content-Type": "image/png"}) + with self.lock: + self.codes["upload " + str(status)] += 1 + if status == 202: + self.uploads.append((json.loads(raw)["id"], headers.get("X-Request-Id"))) + self.stop_event.wait(self.pause) + + def start(self): + for number in range(self.threads): + thread = threading.Thread(target=self._loop, args=(number,), daemon=True) + thread.start() + self._workers.append(thread) + return self + + def stop(self): + self.stop_event.set() + for thread in self._workers: + thread.join(timeout=self.timeout + 5) + + def snapshot(self) -> dict: + with self.lock: + return dict(self.codes) diff --git a/student-tests/upload_memory.py b/student-tests/upload_memory.py new file mode 100644 index 0000000..27ab29e --- /dev/null +++ b/student-tests/upload_memory.py @@ -0,0 +1,164 @@ +"""lab4 (с lab5 — с ответом 202): эксперимент — ≥10 одновременных загрузок и пик памяти реплик API. + + make upload-memory (= python student-tests/upload_memory.py [--count 12]) + +Гипотеза: память реплики почти не растёт с числом одновременных загрузок, потому что +(1) тело читается кусками и в памяти держится не больше 1 МиБ на загрузку (остальное во временном + файле), (2) с lab5 API картинку не декодирует, а только проверяет структуру потоком (по 1 МиБ), + декодирует worker в отдельном процессе, (3) слишком большой файл отклоняется по Content-Length + и вообще не читается. +Если бы тела держались в памяти целиком, только на них ушло бы count × размер файла. + +Методика: +1. обе реплики API перезапускаются (чистый счётчик пика памяти процесса); +2. создаются пользователи и чат (вход — Argon2id, это тоже попадает в базовую линию); +3. замер «до»: VmRSS и VmHWM (пик RSS процесса с момента старта) у PID 1 каждой реплики, + memory.peak cgroup (включает файловый кэш временных файлов); +4. профиль A: count одновременных загрузок PNG со случайными пикселями (8,8 МиБ, 1800×1700); + профиль B: count одновременных запросов, заявляющих 11 МиБ (ожидается 413 без чтения тела); +5. замер «после» и каждые ~0,5 с во время серии (docker exec, VmRSS). +Результат: evidence/upload-memory.json и таблица в REPORT.md (между метками upload-memory). +Ограничения: клиент и стенд на одной машине; VmHWM — пик за всё время процесса, поэтому реплики +перезапускаются перед замером; опрос раз в ~0,5 с может пропустить короткий пик (для этого VmHWM). +""" +import argparse +import concurrent.futures +import hashlib +import json +import re +import threading +import time +from datetime import datetime, timezone + +from filegen import png, raw_upload, wait_status +from helpers import ROOT, Client, check, run +from stand import compose_quiet, docker, wait_balanced + +MIB = 1024 * 1024 +PROBE = "grep -E '^(VmRSS|VmHWM)' /proc/1/status; cat /sys/fs/cgroup/memory.peak 2>/dev/null || echo 0" + + +def memory(container): + """{'rss': МиБ, 'hwm': МиБ, 'cgroup_peak': МиБ} для PID 1 контейнера.""" + text = docker("exec", container, "sh", "-c", PROBE, check_exit=False) + rss = re.search(r"VmRSS:\s+(\d+)", text) + hwm = re.search(r"VmHWM:\s+(\d+)", text) + last = text.strip().splitlines()[-1] if text.strip() else "0" + return {"rss": round(int(rss.group(1)) / 1024, 1) if rss else None, + "hwm": round(int(hwm.group(1)) / 1024, 1) if hwm else None, + "cgroup_peak": round(int(last) / MIB, 1) if last.isdigit() and int(last) else None} + + +class Poller(threading.Thread): + """Во время серии опрашивает VmRSS всех реплик и запоминает максимум.""" + + def __init__(self, containers): + super().__init__(daemon=True) + self.containers, self.stop, self.max_rss = containers, threading.Event(), {c: 0.0 for c in containers} + + def run(self): + while not self.stop.is_set(): + for container in self.containers: + rss = memory(container)["rss"] or 0 + self.max_rss[container] = max(self.max_rss[container], rss) + time.sleep(0.2) + + +def burst(name, count, task): + with concurrent.futures.ThreadPoolExecutor(count) as pool: + started = time.monotonic() + results = list(pool.map(task, range(count))) + took = time.monotonic() - started + print(f"{name}: {count} concurrent uploads in {took:.2f} s -> statuses {sorted(set(r[0] for r in results))}") + return results, round(took, 2) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--count", type=int, default=12) + args = parser.parse_args() + check(args.count >= 10, "the experiment needs >= 10 concurrent uploads") + + compose_quiet("restart", "api") + containers = wait_balanced(2) + api = Client(timeout=60) + alice, bob, _eve, chat = api.bootstrap() + path = f"/api/v1/chats/{chat['id']}/attachments?filename=load.png" + images = [png(1800, 1700, noise=True) for _ in range(args.count)] + size = len(images[0]) + print(f"replicas: {[c[:12] for c in containers]}; {args.count} files x {size / MIB:.1f} MiB " + f"(1800x1700, random pixels)") + before = {c: memory(c) for c in containers} + + poller = Poller(containers) + poller.start() + + def accepted(i): + reply = Client(timeout=60).call("POST", path, 202, actor=alice, raw=images[i], + headers={"Content-Type": "image/png"}, schema="Attachment") + att = reply["json"] + check(att["sha256"] == hashlib.sha256(images[i]).hexdigest(), "checksum mismatch") + return reply["status"], reply["headers"]["X-Instance-Id"], att["id"] + + results_a, took_a = burst("A (accepted)", args.count, accepted) + after_a = {c: memory(c) for c in containers} + + def rejected(_i): + # Заявлено 11 МиБ: сервер должен ответить 413 по заголовку, не читая и не буферизуя тело. + reply = raw_upload(path, alice["token"], b"", content_length=11 * MIB) + return (reply[0] if reply else None), None, None + + results_b, took_b = burst("B (11 MiB, rejected)", args.count, rejected) + check(all(r[0] == 413 for r in results_b), "oversize uploads must get 413") + poller.stop.set() + poller.join() + after_b = {c: memory(c) for c in containers} + + # Все файлы профиля A после обработки worker скачиваются вторым участником без изменений. + for (_s, _inst, att_id), data in zip(results_a, images): + wait_status(api, bob, att_id, seconds=180) + got = api.call("GET", f"/api/v1/attachments/{att_id}/content", actor=bob)["bytes"] + check(got == data, "downloaded file differs") + + rows = [] + for c in containers: + served = sum(1 for r in results_a if c.startswith(r[1])) + rows.append({"replica": c[:12], "uploads_served": served, + "rss_before_mib": before[c]["rss"], "hwm_before_mib": before[c]["hwm"], + "hwm_after_a_mib": after_a[c]["hwm"], "hwm_after_b_mib": after_b[c]["hwm"], + "max_rss_polled_mib": poller.max_rss[c], + "cgroup_peak_after_mib": after_b[c]["cgroup_peak"], + "peak_growth_mib": round((after_a[c]["hwm"] or 0) - (before[c]["hwm"] or 0), 1), + "growth_from_b_mib": round((after_b[c]["hwm"] or 0) - (after_a[c]["hwm"] or 0), 1), + "bodies_if_in_memory_mib": round(served * size / MIB, 1)}) + result = {"date": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), "count": args.count, + "file_mib": round(size / MIB, 2), "profile_a_seconds": took_a, "profile_b_seconds": took_b, + "limits": {"api_memory": "512M", "spool_in_memory": "1 MiB per upload", "structure_checks_concurrency": 2, + "malloc_arena_max": 2}, + "replicas": rows} + (ROOT / "evidence" / "upload-memory.json").write_text(json.dumps(result, indent=2), encoding="utf-8") + + table = ["| Реплика | Загрузок A | RSS до, МиБ | Пик RSS до → после A, МиБ | Рост пика, МиБ " + "| Тела целиком в памяти были бы, МиБ | Рост пика от B (11 МиБ ×{0}), МиБ | memory.peak cgroup, МиБ |" + .format(args.count), "| --- | --- | --- | --- | --- | --- | --- | --- |"] + for r in rows: + table.append(f"| {r['replica']} | {r['uploads_served']} | {r['rss_before_mib']} | {r['hwm_before_mib']} → " + f"{r['hwm_after_a_mib']} | {r['peak_growth_mib']} | {r['bodies_if_in_memory_mib']} | " + f"{r['growth_from_b_mib']} | {r['cgroup_peak_after_mib']} |") + summary = (f"Профиль A: {args.count} одновременных PNG по {size / MIB:.1f} МиБ за {took_a} с, все 202, SHA-256 " + f"совпали при скачивании; профиль B: {args.count} одновременных по 11 МиБ за {took_b} с, все 413. " + f"Лимит памяти реплики 512 МиБ. Сырые данные: evidence/upload-memory.json.") + block = "\n".join([summary, "", *table]) + print(block) + report = ROOT / "REPORT.md" + text = report.read_text(encoding="utf-8") + begin, end = "", "" + if begin in text and end in text: + head, rest = text.split(begin, 1) + report.write_text(head + begin + "\n" + block + "\n" + end + rest.split(end, 1)[1], encoding="utf-8") + print("REPORT.md: table updated between upload-memory markers") + print("PASS: >= 10 concurrent uploads measured; see the table above") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/worker/test_imaging.py b/student-tests/worker/test_imaging.py new file mode 100644 index 0000000..23f798d --- /dev/null +++ b/student-tests/worker/test_imaging.py @@ -0,0 +1,357 @@ +"""lab5: обработка картинок worker (imaging.py, sandbox.py) — проверки внутри образа (там есть Pillow). + + make imaging-test == docker compose --profile tools run --rm imaging-test + +Уровень 3–4 (contracts/README.md, «Фоновая обработка»): +- геометрия: thumbnail вписан в 256×256 без увеличения, размеры вниз, минимум 1 px (320×200 -> 256×160); + crop — центральный квадрат 128×128 (маленькие увеличиваются); optimized — WebP в 1280×1280 без увеличения; +- EXIF-ориентация применяется (фото «на боку» в вариантах стоит правильно); +- прозрачность накладывается на белый в JPEG, а WebP её сохраняет; +- EXIF, GPS, XMP и ICC-профиль в варианты не попадают; +- 16-битные, палитровые, CMYK-картинки обрабатываются; +- одинаковый вход даёт одинаковые байты (повтор задания идемпотентен); +- лимиты worker: пиксели (до декодирования), память (RLIMIT_AS дочернего процесса), время (SIGKILL). +Замечание к MR: проверка структуры JPEG в API (images.py) сверяется здесь с настоящим декодером +worker (libjpeg-turbo в строгом режиме, та же версия, что в образе): +- случайные повреждения заголовков: если API файл пропустил, декодер может споткнуться только + о сжатые данные скана (их без декодирования не проверить), но не о заголовки; если декодер + файл целиком принял, API его тоже не отклоняет; +- полный перебор коэффициентов субдискретизации: API и TurboJPEG принимают одни и те же схемы. +""" +import hashlib +import io +import itertools +import os +import random +import struct +import tempfile +import time +import unittest +import warnings +import zlib +from pathlib import Path + +import simplejpeg +from PIL import Image, ImageCms, ImageOps + +from messenger import images, imaging, sandbox + +FIXTURE = Path(__file__).resolve().parents[2] / "tests" / "fixtures" / "sample.png" + + +def _chunk(kind, data): + return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF) + + +def big_rgba_png(width, height): + """Большой RGBA PNG без Pillow (нули сжимаются в килобайты), чтобы проверить лимиты памяти.""" + compressor = zlib.compressobj(1) + row = b"\x00" + bytes(width * 4) + data = b"".join(compressor.compress(row) for _ in range(height)) + compressor.flush() + ihdr = struct.pack(">IIBBBBB", width, height, 8, 6, 0, 0, 0) + return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", data) + _chunk(b"IEND", b"") + + +# ---------- JPEG по сегментам (для сверки проверки API с декодером) ---------- + +def jpeg_parts(data): + """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): + 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 gradient_jpeg(mode="RGB", size=(48, 32), **options): + image = Image.new(mode, size) + pixels = image.load() + for y in range(size[1]): + for x in range(size[0]): + value = (x * 7 + y * 13) % 256 + pixels[x, y] = value if mode == "L" else tuple((value + k * 60) % 256 for k in range(len(mode))) + out = io.BytesIO() + image.save(out, "JPEG", **options) + return out.getvalue() + + +def api_verdict(data): + """Что ответит API: accept или причина 415 (images.inspect без HTTP).""" + try: + width, height = images._header_size(io.BytesIO(data), "JPEG") + images.check_jpeg(data, width, height) + return "accept" + except Exception as exc: # UnsupportedMediaType / Broken + return f"reject: {exc}" + + +def worker_verdict(data): + """Что скажет worker: строгий libjpeg-turbo (как imaging._strict_jpeg_check) и Pillow.""" + 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) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + with Image.open(io.BytesIO(data)) as image: + image.load() + except Exception as exc: + return str(exc) + return "ok" + + +# Ошибки, которые libjpeg находит только внутри сжатых данных скана (без декодирования не проверить): +# неверный код Хаффмана, данные кончились раньше блоков, лишние байты в конце данных, +# RST не на границе интервала. +ENTROPY_ERRORS = ("bad Huffman code", "premature end of data segment", "extraneous bytes before marker", + "instead of RST") + + +class ImagingTest(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.dir = self.tmp.name + + def tearDown(self): + self.tmp.cleanup() + + def save(self, image, fmt, **kwargs): + path = os.path.join(self.dir, f"in-{len(os.listdir(self.dir))}.{fmt.lower()}") + image.save(path, fmt, **kwargs) + return path + + def run_variants(self, path, content_type, params=imaging.Params()): + out = os.path.join(self.dir, f"out-{len(os.listdir(self.dir))}") + result = imaging.process(path, out, content_type, params) + return {v["name"]: v for v in result["variants"]} + + def opened(self, variant): + img = Image.open(variant["path"]) + img.load() + return img + + def test_fixture_variants(self): + variants = self.run_variants(str(FIXTURE), "image/png") + expected = {"thumbnail": ("JPEG", (256, 160)), "crop": ("JPEG", (128, 128)), "optimized": ("WEBP", (320, 200))} + for name, (fmt, size) in expected.items(): + img = self.opened(variants[name]) + self.assertEqual((img.format, img.size), (fmt, size), name) + self.assertEqual((variants[name]["width"], variants[name]["height"]), size) + self.assertEqual(variants[name]["size_bytes"], os.path.getsize(variants[name]["path"])) + print("\n fixture 320×200 -> thumbnail JPEG 256×160, crop JPEG 128×128, optimized WebP 320×200") + + def test_geometry(self): + cases = {(3000, 1000): ((256, 85), (1280, 426)), (1000, 3000): ((85, 256), (426, 1280)), + (10, 5): ((10, 5), (10, 5)), (5000, 10): ((256, 1), (1280, 2)), + (256, 256): ((256, 256), (256, 256)), (257, 256): ((256, 255), (257, 256)), + (2000, 1999): ((256, 255), (1280, 1279))} + for (w, h), (thumb, optimized) in cases.items(): + with self.subTest(size=(w, h)): + variants = self.run_variants(self.save(Image.new("RGB", (w, h), (90, 120, 150)), "PNG"), "image/png") + self.assertEqual(self.opened(variants["thumbnail"]).size, thumb) + self.assertEqual(self.opened(variants["optimized"]).size, optimized) + self.assertEqual(self.opened(variants["crop"]).size, (128, 128)) # маленькие увеличиваются + + def test_exif_orientation_is_applied(self): + img = Image.new("RGB", (400, 200), (0, 0, 255)) + img.paste((255, 0, 0), (0, 0, 200, 200)) # левая половина красная + exif = Image.Exif() + exif[imaging.EXIF_ORIENTATION] = 6 # «повернуть на 90° по часовой» при показе + path = self.save(img, "JPEG", exif=exif.tobytes(), quality=95) + with Image.open(path) as source: + reference = ImageOps.exif_transpose(source) # как картинку покажет просмотрщик + variants = self.run_variants(path, "image/jpeg") + thumb = self.opened(variants["thumbnail"]) + self.assertEqual((reference.size, thumb.size), ((200, 400), (128, 256))) + top, bottom = thumb.getpixel((64, 20)), thumb.getpixel((64, 236)) + self.assertGreater(top[0], 200) # красная половина — сверху, как у reference + self.assertGreater(bottom[2], 200) + self.assertEqual(reference.getpixel((100, 20))[0] > 200, True) + self.assertEqual(self.opened(variants["optimized"]).size, (200, 400)) + print("\n EXIF orientation 6: stored 400×200 -> variants 128×256 / 200×400, upright like a viewer shows it") + + def test_alpha_is_white_in_jpeg_and_kept_in_webp(self): + transparent = Image.new("RGBA", (100, 80), (0, 0, 0, 0)) + variants = self.run_variants(self.save(transparent, "PNG"), "image/png") + for name in ("thumbnail", "crop"): + pixel = self.opened(variants[name]).convert("RGB").getpixel((5, 5)) + self.assertTrue(all(c >= 250 for c in pixel), f"{name}: {pixel}") + webp = self.opened(variants["optimized"]) + self.assertEqual((webp.mode, webp.getpixel((5, 5))[3]), ("RGBA", 0)) + palette = Image.new("P", (60, 40), 0) + palette.putpalette([0, 0, 0] * 256) + variants = self.run_variants(self.save(palette, "PNG", transparency=0), "image/png") + self.assertTrue(all(c >= 250 for c in self.opened(variants["thumbnail"]).convert("RGB").getpixel((3, 3)))) + + def test_metadata_is_stripped(self): + exif = Image.Exif() + exif[0x010F] = "Camera Maker" + exif[0x8825] = {1: "N", 2: (55.0, 45.0, 0.0)} # GPS-координаты + icc = ImageCms.ImageCmsProfile(ImageCms.createProfile("sRGB")).tobytes() + path = self.save(Image.new("RGB", (300, 200), (10, 200, 30)), "JPEG", exif=exif.tobytes(), icc_profile=icc) + with Image.open(path) as source: + self.assertIn("exif", source.info) + self.assertIn("icc_profile", source.info) + for name, variant in self.run_variants(path, "image/jpeg").items(): + data = Path(variant["path"]).read_bytes() + img = self.opened(variant) + self.assertNotIn("exif", img.info, name) + self.assertNotIn("icc_profile", img.info, name) + self.assertNotIn(b"Exif\x00\x00", data, name) + self.assertNotIn(b"ICC_PROFILE", data, name) + self.assertNotIn(b"Camera Maker", data, name) + + def test_modes(self): + sixteen = Image.new("I;16", (300, 200), 32768) + variants = self.run_variants(self.save(sixteen, "PNG"), "image/png") + self.assertAlmostEqual(self.opened(variants["thumbnail"]).getpixel((10, 10)), 128, delta=2) + cmyk = self.save(Image.new("CMYK", (300, 200), (0, 255, 255, 0)), "JPEG") + thumb = self.opened(self.run_variants(cmyk, "image/jpeg")["thumbnail"]).convert("RGB") + self.assertGreater(thumb.getpixel((10, 10))[0], 200) # красный остался красным + for mode in ("1", "L", "LA", "P", "RGB", "RGBA"): + with self.subTest(mode=mode): + variants = self.run_variants(self.save(Image.new(mode, (64, 48)), "PNG"), "image/png") + self.assertEqual(self.opened(variants["thumbnail"]).size, (64, 48)) + + def test_same_input_same_bytes(self): + first = self.run_variants(str(FIXTURE), "image/png") + second = self.run_variants(str(FIXTURE), "image/png") + self.assertEqual({k: v["sha256"] for k, v in first.items()}, {k: v["sha256"] for k, v in second.items()}) + for variant in first.values(): + self.assertEqual(hashlib.sha256(Path(variant["path"]).read_bytes()).hexdigest(), variant["sha256"]) + + def test_broken_jpeg_scan_is_invalid(self): + good = io.BytesIO() + Image.new("RGB", (64, 48), (200, 100, 50)).save(good, "JPEG") + data = good.getvalue() + sos = data.index(b"\xff\xda") + length = int.from_bytes(data[sos + 2:sos + 4], "big") + broken = data[:sos + 2 + length] + bytes((i * 37 + 11) % 255 for i in range(300)) + b"\xff\xd9" + path = os.path.join(self.dir, "broken.jpg") + Path(path).write_bytes(broken) + with Image.open(path) as lenient: + lenient.load() # Pillow такой файл молча «декодирует»... + with self.assertRaises(imaging.InvalidImage): # ...а строгая проверка libjpeg-turbo — нет + imaging.process(path, os.path.join(self.dir, "o"), "image/jpeg") + + def test_jpeg_header_check_matches_strict_decoder(self): + bases = [gradient_jpeg(), gradient_jpeg(subsampling=0), gradient_jpeg(subsampling=1), + gradient_jpeg(progressive=True), gradient_jpeg(progressive=True, optimize=True), + gradient_jpeg(restart_marker_blocks=1), gradient_jpeg("L"), gradient_jpeg("CMYK"), + gradient_jpeg(size=(130, 70), restart_marker_rows=1), + gradient_jpeg(size=(64, 64), progressive=True, restart_marker_blocks=2)] + for data in bases: + self.assertEqual((api_verdict(data), worker_verdict(data)), ("accept", "ok")) + rnd = random.Random(20261026) + counts = {"both accept": 0, "both reject": 0, "accepted, entropy error in worker": 0} + for _ in range(800): + parts = jpeg_parts(rnd.choice(bases)) + k = rnd.choice([n for n, part in enumerate(parts) if part[0] != "eoi"]) + operation = rnd.randrange(6) + if operation <= 2: # байт в заголовке сегмента или скана + part = parts[k] + payload = bytearray(part[2] if part[0] == "seg" else part[1]) + if payload: + position = rnd.randrange(len(payload)) + payload[position] = rnd.choice([rnd.randrange(256), (payload[position] + 1) % 256, + payload[position] ^ (1 << rnd.randrange(8))]) + parts[k] = ("seg", part[1], bytes(payload)) if part[0] == "seg" else ("scan", bytes(payload), part[2]) + elif operation == 3: # сегмент или скан пропал + del parts[k] + elif operation == 4: # сегмент или скан повторился + parts.insert(k, parts[k]) + else: # лишний или чужой маркер RST в сжатых данных + scans = [n for n, part in enumerate(parts) if part[0] == "scan"] + n = rnd.choice(scans) + entropy = bytearray(parts[n][2]) + position = rnd.randrange(len(entropy)) + entropy[position:position] = bytes([0xFF, 0xD0 + rnd.randrange(8)]) + parts[n] = ("scan", parts[n][1], bytes(entropy)) + data = jpeg_join(parts) + api, worker = api_verdict(data), worker_verdict(data) + with self.subTest(api=api, worker=worker): + if api == "accept": + # Пропущенный API файл не должен падать в worker на заголовках. + self.assertTrue(worker == "ok" or any(e in worker for e in ENTROPY_ERRORS)) + else: + # Отклонённый API файл декодер тоже не принимает целиком. + self.assertNotEqual(worker, "ok") + if api == "accept": + counts["both accept" if worker == "ok" else "accepted, entropy error in worker"] += 1 + else: + counts["both reject"] += 1 + print(f"\n 800 random header mutations: {counts}") + + def test_subsampling_rule_matches_turbojpeg(self): + factors = [(h, v) for h in range(1, 5) for v in range(1, 5)] + cases = [(gradient_jpeg("L"), [(f,) for f in factors]), + (gradient_jpeg(), list(itertools.product(factors, repeat=3))), + (gradient_jpeg("CMYK"), [(y, c, c, k) for y in factors for c in factors for k in factors])] + compared = 0 + for data, combinations in cases: + parts = jpeg_parts(data) + sof = next(n for n, part in enumerate(parts) if part[0] == "seg" and part[1] == 0xC0) + for combination in combinations: + payload = bytearray(parts[sof][2]) + for k, (h, v) in enumerate(combination): + payload[7 + 3 * k] = h * 16 + v + parts[sof] = ("seg", 0xC0, bytes(payload)) + try: + simplejpeg.decode_jpeg_header(jpeg_join(parts)) + decoder = True + except (ValueError, KeyError): # KeyError: схема, которой нет в simplejpeg (4:4:1) + decoder = False + self.assertEqual(images._subsampling_supported(list(combination)), decoder, combination) + compared += 1 + print(f"\n {compared} sampling-factor combinations: API and TurboJPEG agree on every one") + + def test_limits_in_child_process(self): + path = os.path.join(self.dir, "big.png") + Path(path).write_bytes(big_rgba_png(6000, 6000)) # 36 млн пикселей RGBA + params = imaging.Params() + started = time.monotonic() + result = sandbox.run(path, os.path.join(self.dir, "ok"), "image/png", params, timeout=60, memory_limit_mb=640) + normal = time.monotonic() - started + self.assertEqual({v["name"] for v in result["variants"]}, {"thumbnail", "crop", "optimized"}) + with self.assertRaises(imaging.ImageTooLarge): # память: RLIMIT_AS 200 МиБ + sandbox.run(path, os.path.join(self.dir, "m"), "image/png", params, timeout=60, memory_limit_mb=200) + started = time.monotonic() + with self.assertRaises(sandbox.ProcessingTimeout): # время: SIGKILL дочернему процессу + sandbox.run(path, os.path.join(self.dir, "t"), "image/png", params, timeout=0.2, memory_limit_mb=640) + killed_after = time.monotonic() - started + self.assertLess(killed_after, 2) + with self.assertRaises(imaging.ImageTooLarge): # пиксели: до декодирования + imaging.process(str(FIXTURE), os.path.join(self.dir, "p"), "image/png", imaging.Params(max_pixels=1000)) + direct = imaging.process(str(FIXTURE), os.path.join(self.dir, "d"), "image/png") + child = sandbox.run(str(FIXTURE), os.path.join(self.dir, "c"), "image/png", params, 60, 640) + self.assertEqual([v["sha256"] for v in direct["variants"]], [v["sha256"] for v in child["variants"]]) + print(f"\n 36 Mpx RGBA in a child process: ok in {normal:.2f} s with 640 MiB; MemoryError -> image_too_large " + f"with 200 MiB; timeout 0.2 s -> killed after {killed_after:.2f} s; 1000 px limit -> image_too_large") + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/student-tests/worker_crash.py b/student-tests/worker_crash.py new file mode 100644 index 0000000..3b6aec7 --- /dev/null +++ b/student-tests/worker_crash.py @@ -0,0 +1,91 @@ +"""lab5, уровень 4: worker падает после записи объектов, но до ack — повтор даёт тот же результат. + + make worker-crash (= python student-tests/worker_crash.py) + +A. worker_after_objects: оригинал и три варианта уже записаны в S3, COMMIT результата и ack — нет. + Процесс worker падает (os._exit, как SIGKILL), Docker перезапускает контейнер. Брокер снова + доставляет неподтверждённое сообщение; новый процесс видит, что lease держит прежний запуск + ЭТОГО ЖЕ контейнера (значит, тот мёртв), считает попытку неудачной и назначает следующую. + Вторая попытка пишет варианты в ТЕ ЖЕ ключи (ключ эффекта attachment_id/версия/вариант) теми же + байтами, коммитит и подтверждает. Итог: ready, попытка 2, ровно 3 строки и 3 объекта вариантов, + SHA-256 вариантов равны тем, что записала упавшая попытка (вычисляются по самим объектам в S3). +B. worker_after_commit: результат закоммичен, ack не отправлен, worker падает. Повторная доставка + видит ready и подтверждает сообщение без обработки (duplicate_ignored); попытка остаётся 1. +""" +import json +import time + +import ops +from filegen import upload_when_ready, wait_status +from helpers import Client, check, run + +SNAPSHOT = """ +import hashlib, json +from messenger import objects, config +out = {} +for key, _ in objects.list_objects("variants/%s/"): + body = objects.client().get_object(Bucket=config.S3_BUCKET, Key=key)["Body"].read() + out[key] = hashlib.sha256(body).hexdigest() +print(json.dumps(out)) +""" + + +def snapshot(attachment_id): + return json.loads(ops.python("api", SNAPSHOT % attachment_id).splitlines()[-1]) + + +def wait_until(condition, seconds, message): + deadline = time.monotonic() + seconds + while True: + value = condition() + if value: + return value + check(time.monotonic() < deadline, message) + time.sleep(0.5) + + +def main(): + api = Client(timeout=15) + worker = ops.wait_healthy("worker", 1)[0] + alice, bob, _eve, chat = api.bootstrap() + + # ---------- A ---------- + restarts = ops.restarts(worker) + ops.arm("worker", "worker_after_objects", container=worker) + att = upload_when_ready(api, alice, chat, name="worker-crash-a.png")["json"] + print(f"A. worker_after_objects armed; upload -> 202 ({att['id']})") + wait_until(lambda: ops.restarts(worker) > restarts, 60, "the worker did not crash") + crashed = snapshot(att["id"]) + print(f" the worker crashed after writing objects (restart count {restarts} -> {ops.restarts(worker)}); " + f"objects left by the crashed attempt: {len(crashed)}") + ready = wait_status(api, bob, att["id"], seconds=120) + job = ops.job(att["id"]) + final = snapshot(att["id"]) + check(job["job"]["attempt"] == 2, "the retry must be the second attempt") + check(len(job["variants"]) == 3 and len(final) == 3, "exactly one set of variants expected") + check(all(final[key] == digest for key, digest in crashed.items()), "the retry produced different bytes") + check({v["sha256"] for v in ready["variants"]} == set(final.values()), "metadata does not match the objects") + print(" events: " + " -> ".join(f"{e['event']}({e['attempt']})" for e in job["events"])) + print(f" ready at attempt 2; same keys and the same SHA-256 as the crashed attempt wrote: " + f"{sorted(k.rsplit('/', 1)[1] for k in final)}; 3 variant rows") + ops.wait_healthy("worker", 1) + + # ---------- B ---------- + restarts = ops.restarts(worker) + ops.arm("worker", "worker_after_commit", container=worker) + att = upload_when_ready(api, alice, chat, name="worker-crash-b.png")["json"] + print(f"B. worker_after_commit armed; upload -> 202 ({att['id']})") + wait_until(lambda: ops.restarts(worker) > restarts, 60, "the worker did not crash") + wait_status(api, bob, att["id"], seconds=60) + job = wait_until(lambda: (lambda j: j if any(e["event"] == "duplicate_ignored" for e in j["events"]) else None)( + ops.job(att["id"])), 90, "the redelivered message was not seen") + check(job["job"]["attempt"] == 1 and len(job["variants"]) == 3, "the duplicate must not reprocess the job") + print(" events: " + " -> ".join(f"{e['event']}({e['attempt']})" for e in job["events"])) + print(" the redelivered message found the job ready and was acknowledged without processing") + ops.wait_healthy("worker", 1) + print("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") + + +if __name__ == "__main__": + run(main) diff --git a/student-tests/worker_outage.py b/student-tests/worker_outage.py new file mode 100644 index 0000000..78f2417 --- /dev/null +++ b/student-tests/worker_outage.py @@ -0,0 +1,101 @@ +"""lab5, уровень 3: демонстрация из README — worker остановлен, перезапуск API и брокера, задание не потеряно. + + make worker-outage (= python student-tests/worker_outage.py) + +1. worker остановлен (docker compose stop worker); +2. upload -> 202 queued; GET -> queued; /content -> 409 (и для варианта); API ничего не уменьшает сам; +3. сообщение с этим вложением -> 201; обычное текстовое сообщение и история работают; +4. через 5 с вложение всё ещё queued: без worker никто картинку не обрабатывает; +5. задание уже в брокере: строка outbox отправлена (published_at) — до любых перезапусков; +6. перезапуск API (обе реплики) и брокера с сохранением volumes; +7. worker запущен -> то же вложение ready за <= 60 с, thumbnail 256×160 доступен, оригинал тот же. + В outbox для задания по-прежнему одна строка: сообщение пережило перезапуск брокера в его + очереди (quorum queue на volume), его никто не отправлял заново. +ID печатаются, токены — нет. +""" +import hashlib +import time + +import ops +from filegen import SAMPLE_PNG, upload_when_ready, wait_status +from helpers import Client, check, idempotency, run, wait_ready +from image_probe import jpeg_size + + +def main(): + api = Client(timeout=15) + ops.wait_healthy("worker", 1) + alice, bob, _eve, chat = api.bootstrap() + path = f"/api/v1/chats/{chat['id']}" + try: + ops.stop("worker") + print("1. worker stopped:", ops.containers("worker") or "no running worker containers") + + att = upload_when_ready(api, alice, chat, name="while-worker-down.png")["json"] + print(f"2. upload -> 202 {att['status']}, attachment_id={att['id']}") + meta = api.call("GET", f"/api/v1/attachments/{att['id']}", actor=bob, schema="Attachment")["json"] + check(meta["status"] == "queued" and meta["variants"] == [], "must stay queued without a worker") + for suffix in ("", "?variant=thumbnail"): + api.call("GET", f"/api/v1/attachments/{att['id']}/content{suffix}", 409, actor=bob) + print(" GET -> queued, /content -> 409, /content?variant=thumbnail -> 409") + + with_att = api.call("POST", f"{path}/messages", 201, actor=alice, headers=idempotency(), + body={"text": "фото пока обрабатывается", "attachment_ids": [att["id"]]}, + schema="Message")["json"] + text = api.call("POST", f"{path}/messages", 201, actor=bob, headers=idempotency(), + body={"text": "обычное сообщение"}, schema="Message")["json"] + print(f"3. message with the queued attachment -> 201 ({with_att['id']}); text message -> 201 ({text['id']})") + + time.sleep(5) + meta = api.call("GET", f"/api/v1/attachments/{att['id']}", actor=bob, schema="Attachment")["json"] + check(meta["status"] == "queued", "the API must not process images itself") + print("4. after 5 s still queued: the API does not resize synchronously") + + job = ops.job(att["id"]) + published = [o for o in job["outbox"] if o["published_at"]] + check(len(job["outbox"]) == 1 and len(published) == 1, "the job must already be published to the broker") + print(f"5. job {job['job']['job_id']} attempt {job['job']['attempt']}: outbox row published at " + f"{published[0]['published_at']} by {published[0]['published_by']}; queues: {ops.queues()}") + + ops.restart("api") + wait_ready(api, 120) + print("6. api replicas restarted (same containers, volumes kept)") + ops.restart("broker") + ops.wait_healthy("broker", 1, 180) + # Счётчики quorum queue после старта брокера появляются через несколько секунд (очередь + # восстанавливается из журнала на диске), поэтому немного ждём. + deadline = time.monotonic() + 30 + while True: + queues = ops.queues() + if queues.get("attachments.process", (0, 0))[0] >= 1 or time.monotonic() > deadline: + break + time.sleep(1) + print(f" broker restarted with volume rabbitmqdata; queues after restart: {queues}") + meta = api.call("GET", f"/api/v1/attachments/{att['id']}", actor=bob, schema="Attachment")["json"] + check(meta["status"] == "queued", "nothing should process the job while the worker is stopped") + finally: + ops.start("worker") + + started = time.monotonic() + ready = wait_status(api, bob, att["id"], ("ready",), seconds=90) + took = time.monotonic() - started + print(f"7. worker started -> ready after {took:.1f} s") + thumb = [v for v in ready["variants"] if v["name"] == "thumbnail"][0] + got = api.call("GET", f"/api/v1/attachments/{att['id']}/content?variant=thumbnail", actor=bob)["bytes"] + check(jpeg_size(got) == (256, 160) and hashlib.sha256(got).hexdigest() == thumb["sha256"], "thumbnail mismatch") + original = api.call("GET", f"/api/v1/attachments/{att['id']}/content", actor=bob)["bytes"] + check(original == SAMPLE_PNG, "original changed") + history = api.call("GET", f"{path}/messages?limit=100", actor=bob, schema="MessagePage")["json"]["items"] + check(any(m["id"] == with_att["id"] and m["attachment_ids"] == [att["id"]] for m in history), "message lost") + job = ops.job(att["id"]) + check(len(job["outbox"]) == 1, "the message must survive the broker restart, not be published again") + check(len(job["variants"]) == 3, "exactly one set of variants expected") + print(f" thumbnail 256×160 JPEG, original SHA-256 unchanged, message {with_att['id']} keeps the attachment; " + f"outbox rows for the job: {len(job['outbox'])} (published once, before the broker restart)") + print(" job events: " + " -> ".join(f"{e['event']}({e['attempt']})" for e in job["events"])) + print("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") + + +if __name__ == "__main__": + run(main)