From 92ce8c9a59eb4ea0f4db893b0ff02a3b61f1c7a9 Mon Sep 17 00:00:00 2001 From: LOSYASH Date: Thu, 29 Oct 2026 19:53:13 +0300 Subject: [PATCH 1/2] =?UTF-8?q?=D0=9B=D0=A04:=20S3-=D1=85=D1=80=D0=B0?= =?UTF-8?q?=D0=BD=D0=B8=D0=BB=D0=B8=D1=89=D0=B5=20(MinIO)=20=D0=B8=20?= =?UTF-8?q?=D0=B2=D0=BB=D0=BE=D0=B6=D0=B5=D0=BD=D0=B8=D1=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .dockerignore | 39 +- .env.example | 52 ++- .gitattributes | 11 + .github/pull_request_template.md | 16 +- Dockerfile | 27 ++ Makefile | 28 +- REPORT.md | 162 +++++++- app/__init__.py | 0 app/__main__.py | 22 ++ app/config.py | 101 +++++ app/db.py | 50 +++ app/images.py | 235 ++++++++++++ app/janitor.py | 177 +++++++++ app/main.py | 598 +++++++++++++++++++++++++++++ app/migrate.py | 57 +++ app/repo.py | 328 ++++++++++++++++ app/security.py | 46 +++ app/sessions.py | 168 +++++++++ app/storage.py | 211 +++++++++++ app/tools.py | 167 +++++++++ app/uploads.py | 106 ++++++ compose.yaml | 251 +++++++++++++ evidence/attachments.txt | 107 ++++++ evidence/check.txt | 6 + evidence/failover.txt | 52 +++ evidence/no-local-file.txt | 15 + evidence/orphans.txt | 45 +++ evidence/persistence.txt | 27 ++ evidence/s3-bootstrap.txt | 30 ++ evidence/s3-outage.txt | 21 ++ evidence/s3-private.txt | 17 + evidence/smoke.txt | 6 + evidence/stand.txt | 26 ++ evidence/student-tests.txt | 62 ++++ evidence/upload-memory-10.json | 378 +++++++++++++++++++ evidence/upload-memory-20.json | 599 ++++++++++++++++++++++++++++++ evidence/upload-memory.txt | 156 ++++++++ infra/haproxy/haproxy.cfg | 84 +++++ infra/minio/bootstrap.sh | 56 +++ migrations/0001_init.sql | 54 +++ migrations/0002_idempotency.sql | 17 + migrations/0003_attachments.sql | 56 +++ requirements.txt | 12 + scripts/check-s3-private.cmd | 4 + scripts/check-s3-private.sh | 7 + scripts/restart.cmd | 4 + scripts/restart.sh | 6 + scripts/restore-api.cmd | 4 + scripts/restore-api.sh | 5 + scripts/stop-one.cmd | 7 + scripts/stop-one.sh | 12 + student-tests/attachments.py | 259 +++++++++++++ student-tests/collect_evidence.py | 142 +++++++ student-tests/common.py | 202 ++++++++++ student-tests/expiry.py | 49 +++ student-tests/explain.sql | 60 +++ student-tests/failover_each.py | 115 ++++++ student-tests/fixtures/README.md | 7 + student-tests/fixtures/sample.jpg | Bin 0 -> 13406 bytes student-tests/idempotency.py | 91 +++++ student-tests/loadgen.py | 110 ++++++ student-tests/logout_cache.py | 68 ++++ student-tests/orphans.py | 125 +++++++ student-tests/outage.py | 96 +++++ student-tests/race.py | 46 +++ student-tests/rollback_check.py | 52 +++ student-tests/rolling_update.py | 133 +++++++ student-tests/run.py | 122 ++++++ student-tests/s3_outage.py | 83 +++++ student-tests/upload_memory.py | 180 +++++++++ 70 files changed, 6622 insertions(+), 45 deletions(-) create mode 100644 .gitattributes create mode 100644 Dockerfile create mode 100644 app/__init__.py create mode 100644 app/__main__.py create mode 100644 app/config.py create mode 100644 app/db.py create mode 100644 app/images.py create mode 100644 app/janitor.py create mode 100644 app/main.py create mode 100644 app/migrate.py create mode 100644 app/repo.py create mode 100644 app/security.py create mode 100644 app/sessions.py create mode 100644 app/storage.py create mode 100644 app/tools.py create mode 100644 app/uploads.py create mode 100644 compose.yaml create mode 100644 evidence/attachments.txt create mode 100644 evidence/check.txt create mode 100644 evidence/failover.txt create mode 100644 evidence/no-local-file.txt create mode 100644 evidence/orphans.txt create mode 100644 evidence/persistence.txt create mode 100644 evidence/s3-bootstrap.txt create mode 100644 evidence/s3-outage.txt create mode 100644 evidence/s3-private.txt create mode 100644 evidence/smoke.txt create mode 100644 evidence/stand.txt create mode 100644 evidence/student-tests.txt create mode 100644 evidence/upload-memory-10.json create mode 100644 evidence/upload-memory-20.json create mode 100644 evidence/upload-memory.txt create mode 100644 infra/haproxy/haproxy.cfg create mode 100644 infra/minio/bootstrap.sh create mode 100644 migrations/0001_init.sql create mode 100644 migrations/0002_idempotency.sql create mode 100644 migrations/0003_attachments.sql create mode 100644 requirements.txt create mode 100644 scripts/check-s3-private.cmd create mode 100644 scripts/check-s3-private.sh create mode 100644 scripts/restart.cmd create mode 100644 scripts/restart.sh create mode 100644 scripts/restore-api.cmd create mode 100644 scripts/restore-api.sh create mode 100644 scripts/stop-one.cmd create mode 100644 scripts/stop-one.sh create mode 100644 student-tests/attachments.py create mode 100644 student-tests/collect_evidence.py create mode 100644 student-tests/common.py create mode 100644 student-tests/expiry.py create mode 100644 student-tests/explain.sql create mode 100644 student-tests/failover_each.py create mode 100644 student-tests/fixtures/README.md create mode 100644 student-tests/fixtures/sample.jpg create mode 100644 student-tests/idempotency.py create mode 100644 student-tests/loadgen.py create mode 100644 student-tests/logout_cache.py create mode 100644 student-tests/orphans.py create mode 100644 student-tests/outage.py create mode 100644 student-tests/race.py create mode 100644 student-tests/rollback_check.py create mode 100644 student-tests/rolling_update.py create mode 100644 student-tests/run.py create mode 100644 student-tests/s3_outage.py create mode 100644 student-tests/upload_memory.py diff --git a/.dockerignore b/.dockerignore index bc16e556..75492fa1 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,20 +1,39 @@ +# В образ попадает только то, что нужно рантайму. Всё лишнее исключаем: +# уменьшает контекст сборки, ускоряет build и не даёт утечь .env/секретам. .git -.github +.gitignore +.dockerignore +Dockerfile +Dockerfile.example .env .env.* !.env.example -secrets -certs -volumes -data -backups +.venv/ +__pycache__/ +*.py[cod] +tests/ +student-tests/ +scripts/ +contracts/ +evidence/ +*.md +.github/ +lab.json +requirements-dev.txt +compose.yaml +compose.example.yaml +examples/ +Makefile +MAINTAINERS.md +infra/ +secrets/ +certs/ +volumes/ +data/ +backups/ *.key *.pem *.p12 *.pfx *.jks -.venv -__pycache__ -node_modules -evidence .DS_Store diff --git a/.env.example b/.env.example index d99d26a2..07238137 100644 --- a/.env.example +++ b/.env.example @@ -1,20 +1,54 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. +# Скопируйте в .env для ЛОКАЛЬНОГО учебного стенда; .env никогда не коммитится. +# Пароли и ключи ниже — синтетические примеры, задайте свои. APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab -SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: + +# PostgreSQL — источник истины (пользователи, чаты, сообщения, сессии, ключи идемпотентности, +# метаданные вложений). Compose собирает из них DATABASE_URL. Вне compose: DATABASE_URL или DATABASE_URL_FILE. +POSTGRES_DB=messenger +POSTGRES_USER=messenger +POSTGRES_PASSWORD=change-me-local-only + +# Сессии в PostgreSQL, Redis — общий кэш сессий для всех реплик. SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url +SESSION_TTL_SECONDS=3600 +SESSION_CACHE_TTL_SECONDS=60 +# CACHE_URL (или CACHE_URL_FILE) задаёт compose: redis://redis:6379/0. + +# lab3: число реплик API за балансировщиком и срок хранения Idempotency-Key. API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 + +# lab4: MinIO. ROOT — только для сервисов s3 и s3-init (bootstrap), в API не передаётся. +MINIO_ROOT_USER=minio-root +MINIO_ROOT_PASSWORD=change-me-root-local-only +# Отдельный пользователь API с правами только на свой bucket (создаёт s3-init). +# Вне compose можно передать файлами: S3_ACCESS_KEY_ID_FILE / S3_SECRET_ACCESS_KEY_FILE. S3_ENDPOINT=http://s3:9000 S3_REGION=us-east-1 S3_BUCKET=messenger-attachments -S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id -S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key +S3_ACCESS_KEY_ID=messenger-api +S3_SECRET_ACCESS_KEY=change-me-api-local-only +S3_CONNECT_TIMEOUT=2 +S3_READ_TIMEOUT=10 + +# Лимиты загрузки (контракт): 10 MiB и 40 млн пикселей. MAX_UPLOAD_BYTES=10485760 MAX_IMAGE_PIXELS=40000000 +UPLOAD_BODY_TIMEOUT_SECONDS=60 +UPLOAD_SPOOL_MEMORY_BYTES=262144 +UPLOAD_MAX_CONCURRENT=16 +IMAGE_CHECK_CONCURRENCY=2 +# Очистка сирот: журнал загрузки старше grace period считается брошенным. +UPLOAD_GRACE_SECONDS=900 +JANITOR_INTERVAL_SECONDS=60 + +# Пул соединений и таймауты +DB_POOL_MAX=10 +DB_POOL_TIMEOUT=3 +DB_STATEMENT_TIMEOUT_MS=5000 +REDIS_TIMEOUT=0.5 +SHUTDOWN_TIMEOUT=10 + +LOG_LEVEL=info diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..4723f5db --- /dev/null +++ b/.gitattributes @@ -0,0 +1,11 @@ +# Скрипты, которые выполняются ВНУТРИ Linux-контейнеров, обязаны иметь LF, +# даже если репозиторий клонирован на Windows с core.autocrlf=true. +*.sh text eol=lf +*.py text eol=lf +*.sql text eol=lf +*.cfg text eol=lf +*.yaml text eol=lf +Dockerfile text eol=lf +*.cmd text eol=crlf +*.png binary +*.jpg binary diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 1bec5472..d038369f 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,14 +1,14 @@ ## Лабораторная 4 -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO +Автор / группа: Санжаровский, БВТ2304 +Целевая оценка (3/4/5): 4 +Трек 5, если заявлен: не заявлен -Что реализовано и что перенесено: TODO -Команды запуска из чистого clone: TODO -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO -Источники и использование ИИ: TODO +Что реализовано и что перенесено: перенесён lab3 (LB + 2 реплики, PostgreSQL, Redis, идемпотентность). Добавлены MinIO с идемпотентным bootstrap (приватный bucket, отдельный пользователь API с политикой только на свой bucket, консоль выключена, сеть storage internal), миграция 0003 (attachments, message_attachments, upload_intents), потоковый upload PNG/JPEG с проверкой по содержимому и лимитами 10 MiB / 40 Мпикс до распаковки, авторизованный потоковый download, `attachment_ids` в сообщениях, компенсация + janitor с grace period, собственные тесты уровня 4 и эксперимент памяти. +Команды запуска из чистого clone: `cp .env.example .env` → `docker compose --env-file .env up -d --build` → `make test` → `python student-tests/collect_evidence.py` (подробно в REPORT.md). +Результаты проверок и ссылка на REPORT.md: REPORT.md, раздел «Доказательства критериев»; вывод — в `evidence/`. +Ограничения / известные ошибки: REPORT.md, раздел «Ограничения». +Источники и использование ИИ: REPORT.md, шапка. - [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. - [ ] Контракт и публичные тесты не ослаблены. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..0237de68 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,27 @@ +# syntax=docker/dockerfile:1 + +# ---- Stage 1: builder: зависимости ставим отдельно, в рантайм несём только результат +FROM python:3.12.7-slim-bookworm AS builder +ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PIP_NO_CACHE_DIR=1 PIP_DISABLE_PIP_VERSION_CHECK=1 +WORKDIR /app +COPY requirements.txt . +RUN pip install --prefix=/install -r requirements.txt + +# ---- Stage 2: runtime +FROM python:3.12.7-slim-bookworm AS runtime +ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 \ + APP_HOST=0.0.0.0 APP_PORT=8080 SHUTDOWN_TIMEOUT=10 +RUN useradd --create-home --uid 10001 appuser +WORKDIR /app +COPY --from=builder /install /usr/local +COPY app ./app +COPY migrations ./migrations +USER appuser +EXPOSE 8080 +# /health/ready проверяет PostgreSQL: без БД контейнер станет unhealthy. +HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \ + CMD python -c "import os,urllib.request,sys; \ +u='http://127.0.0.1:'+os.getenv('APP_PORT','8080')+'/health/ready'; \ +sys.exit(0 if urllib.request.urlopen(u,timeout=2).status==200 else 1)" || exit 1 +# exec-форма: uvicorn — PID 1 и сам получает SIGTERM от docker stop. +CMD ["python", "-m", "app"] diff --git a/Makefile b/Makefile index 5d86d171..2196fc79 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,8 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +.PHONY: help check validate test load test-persistence test-failover \ + test-student test-attachments test-orphans test-s3-outage test-upload-memory check-s3-private evidence help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -28,3 +29,28 @@ 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) + +# ---- lab4: собственные проверки (стенд должен быть запущен) ---- +test-student: + $(PYTHON) student-tests/run.py --base-url "$(BASE_URL)" + $(PYTHON) student-tests/idempotency.py --base-url "$(BASE_URL)" + +test-attachments: + $(PYTHON) student-tests/attachments.py --base-url "$(BASE_URL)" + +# Нужна реплика с внедрением отказов: docker compose --env-file .env --profile fault up -d api-fault +test-orphans: + $(PYTHON) student-tests/orphans.py --base-url "$(BASE_URL)" --fault-url http://localhost:8082 + +test-s3-outage: + $(PYTHON) student-tests/s3_outage.py --base-url "$(BASE_URL)" + +test-upload-memory: + $(PYTHON) student-tests/upload_memory.py --base-url "$(BASE_URL)" --concurrency 10 --output evidence/upload-memory-10.json + +check-s3-private: + sh scripts/check-s3-private.sh + +# Все проверки lab4 подряд с сохранением вывода в evidence/ (кроссплатформенно, Python) +evidence: + $(PYTHON) student-tests/collect_evidence.py --base-url "$(BASE_URL)" diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..912600e3 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,165 @@ # Отчёт — лабораторная 4 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Санжаровский, БВТ2304 +- Целевая оценка: **4** (трек 5 не заявлен) +- Commit/PR: ветка `solution/bvt2304-sanzharovskiy` форка `Anatoly01/mtusi2026lab4`, PR в `mtusi2026/mtusi2026lab4` +- Источники и библиотеки: всё из lab3 (FastAPI, uvicorn, psycopg 3 + psycopg-pool, argon2-cffi, redis-py, HAProxy 3.0) + **boto3/botocore 1.38** (S3-клиент), **Pillow 11.2** (декодирование JPEG), MinIO — сборка сообщества Pigsty `pgsty/minio:RELEASE.2026-08-04T00-00-00Z` и клиент `pgsty/mc:RELEASE.2026-09-16T00-00-00Z` (официальные `minio/minio` удалены с Docker Hub, `quay.io/minio` отвечает 401 на анонимный pull); спецификация PNG (структура чанков, CRC, Adam7); документация MinIO (`mc mb`, `mc anonymous`, `mc admin policy/user`); AWS S3 docs (Content-MD5, политики). ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужно: Docker Desktop (Compose v2), Python 3.9+ для тестов (только stdlib). Образы закреплены: `python:3.12.7-slim-bookworm`, `postgres:16.4-alpine`, `redis:7.4.1-alpine`, `haproxy:3.0.5-alpine`, `pgsty/minio:RELEASE.2026-08-04T00-00-00Z`, `pgsty/mc:RELEASE.2026-09-16T00-00-00Z`. + +```sh +cp .env.example .env # Windows: copy .env.example .env — задать свои пароли/ключи +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +# порядок старта: postgres(healthy) → migrate (exit 0) +# s3(healthy: mc ready local) → s3-init (bootstrap, exit 0) → api ×2 → lb +curl -i http://localhost:8080/health/ready # 200 + X-Instance-Id +make check && make test # публичные проверки +python student-tests/collect_evidence.py # ВСЕ проверки lab4 → evidence/*.txt (+ сводка) +``` + +Windows: публичные `tests/` читают JSON кодировкой по умолчанию (cp1251) — перед запуском `set PYTHONUTF8=1` (или `python -X utf8 …`); `collect_evidence.py` выставляет это сам. Без `make`: `python scripts/check_contract.py`, `python tests/smoke.py --base-url http://localhost:8080`, хуки `scripts\restart.cmd`, `scripts\stop-one.cmd`, `scripts\restore-api.cmd`, `scripts\check-s3-private.cmd`. + +Отдельные проверки: + +```sh +python student-tests/attachments.py --base-url http://localhost:8080 # негативный набор уровня 4 +docker compose --env-file .env --profile fault up -d api-fault # реплика с внедрением отказов +python student-tests/orphans.py --base-url http://localhost:8080 --fault-url http://localhost:8082 +python student-tests/s3_outage.py --base-url http://localhost:8080 # сам делает stop/start s3 +python student-tests/upload_memory.py --concurrency 10 --output evidence/upload-memory-10.json +scripts/check-s3-private.sh # приватность bucket вне API +docker compose --env-file .env run --rm s3-init # повторный bootstrap = no-op +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-failover ACTION_SCRIPT=scripts/stop-one.sh && scripts/restore-api.sh +``` + +Остановка без потери данных: `docker compose --env-file .env down`. Намеренное удаление учебных данных (БД **и** bucket): `docker compose --env-file .env down -v`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +клиент ──▶ lb (HAProxy, 127.0.0.1:8080) ──roundrobin──▶ api #1 ─┬─▶ postgres (пользователи, чаты, сообщения, + api #2 ─┤ метаданные вложений; volume pgdata) + ├─▶ redis (кэш сессий) + сеть app ──────────────────────────────────────────────┘ + сеть storage (internal) ── api ×2 ──▶ s3 = MinIO (приватный bucket, volume s3data; портов наружу нет) + s3-init (однократно): bucket + политика + пользователь API +``` + +| Роль | Service | Версия | Health/readiness | Volume | Порт | Credentials | +| --- | --- | --- | --- | --- | --- | --- | +| load_balancer | `lb` | `haproxy:3.0.5-alpine` | `/healthz`; backend `/health/ready` | — | `127.0.0.1:8080` (+8081 ttl, +8082 fault — только тестовые профили) | — | +| api ×2 | `api` | `Dockerfile` | `/health/ready` (PostgreSQL) | **нет** (stateless) | только `expose 8080` | `POSTGRES_*`, `S3_ACCESS_KEY_ID/S3_SECRET_ACCESS_KEY` (ограниченный пользователь) | +| миграции | `migrate` | тот же образ | exit 0 → старт api | — | — | `POSTGRES_*` | +| postgres | `postgres` | `postgres:16.4-alpine` | `pg_isready` | `pgdata` | внутренняя | `POSTGRES_*` | +| redis | `redis` | `redis:7.4.1-alpine` | `redis-cli ping` | — (кэш) | внутренняя | — | +| s3 | `s3` | `pgsty/minio:RELEASE.2026-08-04T00-00-00Z` | `mc ready local` | `s3data` | **нет**, сеть `storage` (internal), консоль выключена | `MINIO_ROOT_*` — только s3 и s3-init | +| bootstrap S3 | `s3-init` | `pgsty/mc:RELEASE.2026-09-16T00-00-00Z` | exit 0 → старт api | — | — | `MINIO_ROOT_*` | + +**Что перенесено из lab3** без изменений: LB + 2 реплики без локального состояния, общие сессии (PostgreSQL + Redis-кэш), идемпотентность сообщений, отдельный `migrate`, graceful shutdown, лимиты CPU/RAM, хуки `restart`/`stop-one`/`restore-api`, все student-tests lab2–3. + +**Что добавлено в lab4:** + +- **Модель данных** (`migrations/0003_attachments.sql`): `attachments` (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, width, height, status, error_code, object_key, created_at, updated_at; CHECK на тип, размер ≤10 MiB, sha256, длину имени); `message_attachments` (message_id, attachment_id, position — порядок из запроса; одно вложение можно приложить к нескольким сообщениям своего чата); `upload_intents` (журнал загрузок для компенсации). CHECK текста сообщения ослаблен до `≤ 4000`: пустой текст разрешает API только вместе с вложениями. Миграция только добавляет — версия lab3 с новой схемой работает (rolling update возможен). +- **Ключ объекта** назначает сервер: `originals/`. `filename` — только для отображения (в JSON и `Content-Disposition` через RFC 5987), в ключ/путь не попадает. В публичный JSON не попадают `object_key`, bucket, адрес S3. +- **Upload** `POST /api/v1/chats/{id}/attachments?filename=…` (сырые байты): порядок проверок — Bearer (401) → участник чата (404) → filename (400) → заявленный `Content-Type` ∈ {png, jpeg} (415) → `Content-Length` > 10 MiB → **413 без чтения тела** → потоковое чтение тела с подсчётом SHA-256/MD5 и обрывом на 10 MiB + 1 байт (413, работает и для chunked) → проверка содержимого (`app/images.py`) → журнал → PUT в S3 → транзакция метаданных → **201 ready** (`variants=[]`, `error_code=null`). +- **Проверка изображения по содержимому** (`app/images.py`): сигнатура (magic bytes) должна совпасть с заявленным типом, иначе 415 (подмена MIME). Пиксели берутся из заголовка (PNG IHDR / JPEG SOF) и проверяются **до распаковки** (> 40 млн → 413) — «бомба» 8000×8000 в 60 КБ отсекается мгновенно. Целостность: PNG разбирается потоково — CRC каждого чанка, IDAT распаковывается порциями по 64 КиБ, проверяются байты фильтров строк и точное совпадение объёма данных с IHDR (с учётом Adam7); пиксели не сохраняются. JPEG декодируется Pillow в режиме `draft` (масштаб 1/8) — весь поток проверяется декодером, памяти нужно в ~64 раза меньше. Усечённые/битые файлы → 415. +- **Download** `GET /api/v1/attachments/{id}/content`: доступ только участникам чата (иначе одинаковый 404 — существование не раскрывается), байты идут из S3 потоком по 64 КиБ (`StreamingResponse`), `Content-Type` — истинный тип из метаданных, плюс `Content-Length`, `ETag: ""`, `X-Content-Type-Options: nosniff`, `Cache-Control: private, no-cache`. Без redirect и presigned URL. `variant=original` по умолчанию; известные варианты lab5 (thumbnail…) → 404, неизвестное имя → 400. +- **Сообщения**: `attachment_ids` (0–10, уникальные UUID; нет поля == `[]`), `text=""` допустим только с вложениями. Вложения проверяются в той же транзакции, что и запись сообщения (`SELECT … FOR SHARE`): нет/из другого чата → 404, дубликаты/>10/не UUID → 400. Хэш идемпотентности включает `attachment_ids` только если список не пуст — ключи lab3 после обновления дают тот же хэш; другой набор вложений с тем же ключом → 409. +- **S3 недоступен** → upload/download дают 503 `unavailable` за время таймаутов (connect 2 c, read 10 c, 2 попытки), а не зависание. Первый прогон показал 28 c на upload: остановленный `s3` перестаёт резолвиться, а встроенный DNS Docker в `internal`-сети ждёт внешний резолвер (≈7 c на запрос × 2 попытки PUT × 2 попытки DELETE компенсации). Исправлено: у реплик API `dns_opt: timeout:1, attempts:1` и предохранитель (circuit breaker) в `app/storage.py` — после ошибки соединения с S3 следующие `S3_BREAKER_SECONDS`=5 c запросы к S3 сразу получают 503; метаданные, текстовые сообщения и `/health/ready` работают. `/health/ready` проверяет **только PostgreSQL** (критичная зависимость обязательного текстового пути); S3 — некритичная зависимость для вложений. + +### Согласованность PostgreSQL ↔ S3 (что если PUT прошёл, а COMMIT — нет) + +``` +1. INSERT upload_intents(object_key) ; COMMIT ← намерение записано ДО записи в S3 +2. PUT originals/ в S3 (Content-MD5 — S3 сверяет целостность) +3. BEGIN; DELETE FROM upload_intents … RETURNING; INSERT attachments …; COMMIT → 201 +``` + +| Где сбой | Что остаётся | Кто убирает | +| --- | --- | --- | +| клиент оборвал тело / таймаут тела (60 c) | ничего: в S3 не писали, буфер запроса удалён в `finally` | — | +| файл не прошёл проверку | ничего | — | +| PUT в S3 упал | строка журнала (объекта нет) | API сразу (компенсация), иначе janitor | +| PUT прошёл, ошибка в шаге 3 | объект + строка журнала | API сразу: удаляет объект и строку, отвечает 503 (не 201) | +| процесс убит между 2 и 3 (kill -9, OOM) | объект + строка журнала | janitor после grace period | +| объект без журнала (страховка) | объект | janitor `--scan-bucket` после grace period | + +**Janitor** (`app/janitor.py`) работает фоновой задачей в каждой реплике раз в `JANITOR_INTERVAL_SECONDS` (60 c), но одновременно только в одной — `pg_try_advisory_lock`. Строку журнала старше `UPLOAD_GRACE_SECONDS` он удаляет **в транзакции** вместе с объектом: `DELETE … RETURNING` (строка заблокирована) → `DELETE` объекта в S3 → `COMMIT`. Ошибка S3 → ROLLBACK, повтор на следующем проходе; падение после удаления объекта → повторное удаление безопасно (DELETE в S3 идемпотентен). Раз в ~час — обход bucket (`originals/`): объект старше grace без строки в `attachments` и `upload_intents` — сирота. Ручной запуск: `python -m app.janitor --once [--dry-run] [--scan-bucket] [--grace-seconds N]`. + +**Grace period = 900 c.** Живая загрузка не длится дольше 60 c (таймаут тела) + ~30 c (S3/БД) — запас в 10 раз. Даже если загрузка «проспала» grace, шаг 3 удаляет строку журнала в одной транзакции с INSERT метаданных: если janitor уже её забрал (и удалил объект), загрузка получит 0 строк, откатится и ответит 503 — **201 на удалённый объект невозможен**. Готовые вложения (есть строка в `attachments`) janitor не трогает никогда. + +### Память и лимиты загрузки + +- Тело не накапливается в RAM: `SpooledTemporaryFile` держит в памяти ≤ `UPLOAD_SPOOL_MEMORY_BYTES` (256 КиБ), дальше — временный файл, удаляемый сразу после ответа. Это буфер одного запроса, а не хранилище: оригинал существует только в S3 (проверка `app.tools find-local` — на дисках реплик нет файлов с SHA-256 оригинала; у api нет volumes). +- Проверка изображения: O(64 КиБ) для PNG, ~(W×H/64)×3 байт для JPEG; одновременно ≤ `IMAGE_CHECK_CONCURRENCY`=2 проверки на реплику (CPU), ≤ `UPLOAD_MAX_CONCURRENT`=16 загрузок на реплику, остальные ждут в очереди. +- PUT в S3 читает тот же буфер потоком; скачивание — поток по 64 КиБ. +- Argon2id (перенесён из lab2) по умолчанию берёт 64 МиБ на хэш. Первый прогон lab4: 20 параллельных регистраций (`run.py`) не уложились в таймаут, и сразу после этого `idempotency.py` видел только одну реплику — память реплики (база ≈ +30 МиБ из‑за boto3/Pillow) переполнялась одновременными хэшами. Исправлено: не больше `PASSWORD_HASH_CONCURRENCY`=2 хэшей на реплику одновременно (`app/main.py: kdf`), остальные ждут. +- Таймауты: тело — 60 c, S3 connect/read — 2/10 c, БД — как в lab3; HAProxy `timeout server` поднят до 30 c. + +### Приватность и права S3 + +- `s3-init` (`infra/minio/bootstrap.sh`) идемпотентен: `mc mb --ignore-existing`, `mc anonymous set none`, `mc admin policy create` (перезапись), `mc admin user add` (обновление секрета), `attach` (повтор — no-op), затем проверка `mc admin user info`, что политика действительно привязана (иначе exit 1). Повторный `docker compose run --rm s3-init` — тот же результат. +- API ходит **отдельным** пользователем `S3_ACCESS_KEY_ID` с политикой `lab4-api-rw`: `GetObject/PutObject/DeleteObject` на `bucket/*` и `ListBucket/GetBucketLocation` на bucket. Root MinIO в API не передаётся; bootstrap отказывается работать, если ключ API совпадает с root. +- Админ-консоль: `MINIO_BROWSER=off`, у `s3` нет `ports`, сеть `storage` — `internal: true`, к ней подключены только `s3`, `s3-init` и реплики API (LB и хост — нет). +- Проверка вне API (`scripts/check-s3-private.sh` → `python -m app.tools private-check`): прямые запросы к MinIO **без подписи** (GET объекта, LIST, PUT) → 403; ключами API: `ListBuckets`, `CreateBucket`, `PutBucketPolicy` (сделать bucket публичным), `DeleteBucket` → `AccessDenied`; позитивный контроль — свой объект читается. С хоста порты 9000/9001 закрыты. + +**Соответствие `.env.example`:** `S3_BUCKET`, `S3_REGION`, `S3_ACCESS_KEY_ID`, `S3_SECRET_ACCESS_KEY`, `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS` используются как есть; `S3_ENDPOINT` в compose фиксирован `http://s3:9000`; `*_FILE`-варианты поддерживаются (`app/config.py: _secret`, файл приоритетнее); `MINIO_ROOT_*` — только для `s3`/`s3-init`. Остальное — как в lab3. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +Стенд: ПК с Windows и Docker Desktop, стек из `compose.yaml` как есть (`API_REPLICAS=2`, api 0,5 CPU / 256 МиБ), прогон 29.10.2026. Все файлы `evidence/` получены командой `python student-tests/collect_evidence.py --base-url http://localhost:8080` (отдельные шаги — `--only имя`); тесты запускались с хоста через LB. -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл | +| --- | --- | --- | --- | +| Публичный smoke | `make check`, `make test` | `PASS: offline skeleton…`; `PASS: lab4 public API scenario` | `evidence/check.txt`, `evidence/smoke.txt` | +| Возможности lab3 сохранены | `student-tests/run.py`, `idempotency.py`, persistence, failover | run.py 25/25 (в т.ч. 20 параллельных регистраций → один 201 и 19×409), idempotency 16/16 (20 повторов через 2 реплики → одно сообщение) | `evidence/student-tests.txt` | +| S3 в стенде, метаданные в PostgreSQL, байты в приватном bucket, не на API | `docker compose ps`; `app.tools find-local ` в обеих репликах; `docker inspect` mounts | 6 сервисов healthy, `s3` без опубликованных портов; в обеих репликах `files_scanned: 52, copies_found: []`; у api `mounts=[]`; `migrate` повторно — `applied: nothing` | `evidence/stand.txt`, `evidence/no-local-file.txt` | +| 201 ready после сохранения, побайтное скачивание, 404 постороннему | `make test`, `student-tests/attachments.py` | 201 `ready`, `variants=[]`, sha256/size оригинала; второй участник скачивает те же байты (sha256), `Content-Type: image/png`, `nosniff`; посторонний — 404 на метаданные и байты | `evidence/smoke.txt`, `evidence/attachments.txt` | +| Лимиты, MIME по содержимому, опасные filename | `attachments.py` (разделы «размер», «пиксели», «повреждённые», «подмена MIME», «filename») | 413: `Content-Length` 10 MiB+1 (тело не отправлялось), 500 MiB, chunked > 10 MiB, реальный PNG 11,4 МБ, «бомба» 8000×8000 в 62 КБ, 40 040 001 пикс.; 415: 6 видов битых файлов и 8 подмен MIME; 400: 13 опасных/пустых/длинных имён | `evidence/attachments.txt` | +| Upload → остановка обслужившей реплики → download через другую | `tests/resilience.py --mode failover` ×2 (разные реплики) | PASS ×2: 2 реплики до отказа, 113/115 записей, 0 неудачных попыток, восстановление 2,03 / 1,84 c; файл скачан с тем же содержимым | `evidence/failover.txt` | +| Restart всего стенда с volumes | `tests/resilience.py --mode persistence`, hook `scripts/restart.cmd` (postgres, redis, **s3**, api, lb) | PASS: тот же токен читает те же данные и тот же файл; `docker compose ps` до/после — все контейнеры перезапущены (Up 3–7 s) | `evidence/persistence.txt` | +| **4:** тесты отказных сценариев, нет 500 | `attachments.py` (+ fuzz: 30 случайно испорченных PNG/JPEG) | 90 passed, 0 failed; «no 500 and no dropped connection among 99 checked responses»; fuzz → только 201/415. Первый прогон нашёл 500 на PNG с испорченным байтом в IDAT (`zlib.error` не перехватывался) — исправлено в `app/images.py`, локально проверено на ~2500 порчах | `evidence/attachments.txt` | +| **4:** компенсация/очистка с grace period | `orphans.py` + реплика `api-fault` | 17/17: прерванная загрузка — ничего не осталось; отказ БД после PUT — 503 и объект удалён сразу; kill после PUT — клиент получил 502, остались 1 объект + 1 строка журнала; janitor с grace 900 c их не трогает, dry-run ничего не меняет, после grace удаляет (33 мс), повтор — no-op; объект без журнала найден обходом bucket (36 объектов, 87 мс); готовое вложение цело | `evidence/orphans.txt` | +| **4:** лимиты/таймауты/потоковая обработка, ≥10 одновременных загрузок, пик памяти | `upload_memory.py --concurrency 10` и `20` | 30/30 и 60/60 → 201, все sha256 совпали; рост памяти процессов (anon) на реплику +21 / +27 МиБ, пик usage 128 / 157 МиБ при лимите 256 (таблица ниже) | `evidence/upload-memory-10.json`, `-20.json`, `upload-memory.txt` | +| **4:** идемпотентный bootstrap | `docker compose run --rm s3-init` ×2 | оба exit 0, одинаковый вывод: bucket private, `verified: API user has policy lab4-api-rw` | `evidence/s3-bootstrap.txt` | +| **4:** отдельные ограниченные credentials, консоль закрыта, private bucket вне API | `app.tools private-check`; TCP 127.0.0.1:9000/9001 с хоста | 8/8: аноним GET/LIST/PUT → 403; ключами API `ListBuckets` видит только свой bucket, `CreateBucket`/`PutBucketPolicy`/`DeleteBucket` → AccessDenied; порты 9000 и 9001 на хосте закрыты | `evidence/s3-private.txt` | +| Недоступность S3 | `s3_outage.py` | upload → 503 `unavailable` за 5,6 c (первый прогон — 28,3 c, исправлено, см. «Архитектура»), download → 503, метаданные/текст/`ready` работают, файл после восстановления не изменился, janitor дочистил журнал | `evidence/s3-outage.txt` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +**Пик памяти при одновременных загрузках** (`student-tests/upload_memory.py`). +Гипотеза: память реплики почти не растёт с числом одновременных загрузок, потому что тело не копится в RAM, проверка изображения потоковая, а в S3 и клиенту уходит поток. Наивная реализация (`await request.body()` + полная декодировка Pillow) держала бы ≥ 2 × 9,5 МБ на загрузку + 1780×1780×3 ≈ 9,1 МБ на декодированный кадр: 10 одновременных загрузок на реплику ≈ 280 МБ — больше лимита контейнера 256 МБ (OOM). +Методика: PNG из шума 1780×1780 (10 026 738 байт ≈ 9,56 МиБ, почти не сжимается), N = 10 и 20 потоков, 3 раунда, через LB на 2 реплики (0,5 CPU / 256 МиБ каждая), клиент на том же ПК. Каждые ~0,3–0,6 c читается cgroup v2 каждого контейнера api: `usage` (= current − inactive_file, как `docker stats`), `anon` (память процессов без файлового кэша), `memory.peak`. Проверяются коды ответов и SHA-256 каждой загрузки, выборочно скачивание. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +| N (на реплику) | загрузок | 201 / sha ok | в покое usage (anon), МиБ | пик usage (anon), МиБ | рост usage / anon, МиБ | p50 / max, c | МиБ/c | +| --- | --- | --- | --- | --- | --- | --- | --- | +| 10 (≈5) | 30 | 30 / 30 | 75,3 (70,2) | 128,2 (91,1) | +53,5 / +21,2 | 2,86 / 3,47 | 30,1 | +| 20 (≈10) | 60 | 60 / 60 | 84,5 (79,1) | 156,7 (105,5) | +72,9 / +26,5 | 5,39 / 7,81 | 28,5 | + +Вывод: гипотеза подтверждена. Удвоение одновременных загрузок увеличило память процессов (anon) лишь с +21 до +27 МиБ (≈2,6 МиБ на одновременную загрузку: буфер 256 КиБ, куски по 64 КиБ, буферы boto3/потоков), а не на 10 × 9,56 МиБ. Рост `usage` больше, чем `anon`, за счёт page cache временных файлов буфера — это reclaimable-память, после нагрузки она возвращается (84 → 92 МиБ). Пропускная способность ≈ 29 МиБ/c и не растёт с N — ограничение CPU (0,5 CPU × 2 на SHA-256/MD5, проверку PNG и подпись S3), лишние загрузки ждут в очереди (латентность растёт пропорционально N). `memory.peak` = 214 МиБ был зафиксирован ещё до эксперимента — это хэширование паролей Argon2id (2 × 64 МиБ) в предыдущих тестах; поэтому их число и ограничено (`PASSWORD_HASH_CONCURRENCY`). + +Контрольный опыт (по желанию): `UPLOAD_SPOOL_MEMORY_BYTES=10485760` (весь файл в RAM) — `set UPLOAD_SPOOL_MEMORY_BYTES=10485760` и `docker compose --env-file .env up -d api`, тот же прогон; затем вернуть значение по умолчанию. + +Ограничения измерения: клиент и стенд на одном ПК (closed loop), выборки раз в ~0,3–0,6 c могут пропустить кратковременный пик; один прогон на N, без повторов; Docker Desktop (WSL2), а не выделенный сервер. + +| Воздействие | Что ожидаем | Что наблюдали | Восстановление / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| остановка обслужившей реплики после upload | download через другую, тот же файл | PASS ×2, 0 неудачных попыток | 2,03 / 1,84 c, потерь нет | +| рестарт postgres+redis+s3+api+lb | метаданные и оригинал на месте, тот же токен | PASS | несколько секунд до ready, потерь нет | +| MinIO остановлен | upload/download 503 за ≤ таймаутов, текст/метаданные/ready работают | 503 за 5,6 c (до исправления — 28,3 c); текст, метаданные и `/health/ready` работают | после старта MinIO файл тот же; до 5 c на реплику 503 (предохранитель) | +| БД упала после PUT (fault) | 503, объект удалён компенсацией | 503, объектов/строк журнала не прибавилось | сразу | +| процесс убит после PUT (fault) | сирота видна в журнале, janitor удаляет после grace | клиент — 502; +1 объект, +1 строка журнала, 0 метаданных; удалены janitor | ≤ grace (900 c) + интервал (60 c); в тесте grace 5 c | +| прерванная загрузка | ничего не остаётся | счётчики объектов/метаданных/журнала не изменились | — | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- MinIO — один узел без erasure coding: отказ его диска/хоста = недоступность файлов. Единичные точки отказа LB/PostgreSQL/Redis — как в lab3. +- Временный файл буфера запроса пишется в слой контейнера (`/tmp`): при одновременных загрузках нужен диск ≈ N × 10 MiB; файл удаляется сразу после ответа. Для lab5 staging должен стать устойчивым (S3-prefix), а не диском API. +- Проверка JPEG доверяет libjpeg: часть «мягких» повреждений (испорченные коэффициенты в середине) декодер прощает — файл примется и скачается побайтно, но может отображаться с артефактами. +- Скачивание идёт через API (так требует контракт) — трафик и CPU реплики растут с размером файлов; presigned-download — трек 5. +- Обход bucket (`--scan-bucket`) линейный (листинг всех объектов `originals/`); для миллионов объектов нужен инкрементальный reconciler (трек 2). +- `X-Instance-Id` — по-прежнему короткий ID контейнера (в lab7 — случайный alias). diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/__main__.py b/app/__main__.py new file mode 100644 index 00000000..31667101 --- /dev/null +++ b/app/__main__.py @@ -0,0 +1,22 @@ +""" +Точка входа контейнера: `python -m app`. Настройки — из окружения (app/config.py). +uvicorn ловит SIGTERM: перестаёт принимать запросы и дожидается текущих +(до SHUTDOWN_TIMEOUT), затем закрывает пул БД и соединение с Redis. +""" +import logging + +import uvicorn + +from .config import settings + +if __name__ == "__main__": + logging.basicConfig(level=settings.log_level.upper(), + format="%(asctime)s %(levelname)s %(name)s %(message)s") + uvicorn.run( + "app.main:app", + host=settings.host, + port=settings.port, + timeout_graceful_shutdown=settings.shutdown_timeout, + access_log=False, # свой лог в middleware: без query, токенов и тел + log_level=settings.log_level, + ) diff --git a/app/config.py b/app/config.py new file mode 100644 index 00000000..01d0993d --- /dev/null +++ b/app/config.py @@ -0,0 +1,101 @@ +""" +Конфигурация только из переменных окружения (ничего не зашито в код и образ). +""" +from __future__ import annotations +import os +import socket +from dataclasses import dataclass + + +def _int(name: str, default: int) -> int: + return int(os.getenv(name, str(default))) + + +def _float(name: str, default: float) -> float: + return float(os.getenv(name, str(default))) + + +def _secret(name: str, default: str = "") -> str: + """Значение из NAME_FILE (Docker secret, файл) или из переменной NAME. + Файл приоритетнее: так credentials не видны в `docker inspect`.""" + path = os.getenv(name + "_FILE") + if path: + with open(path, encoding="utf-8") as f: + return f.read().strip() + return os.getenv(name, default) + + +@dataclass(frozen=True) +class Settings: + # HTTP + host: str = os.getenv("APP_HOST", "0.0.0.0") + port: int = _int("APP_PORT", 8080) + shutdown_timeout: int = _int("SHUTDOWN_TIMEOUT", 10) + log_level: str = os.getenv("LOG_LEVEL", "info") + # Имя реплики для X-Instance-Id: INSTANCE_ID или hostname контейнера + # (в Docker это короткий ID контейнера — по нему stop-one.sh находит реплику). + instance_id: str = os.getenv("INSTANCE_ID") or socket.gethostname() + + # PostgreSQL — источник истины + database_url: str = _secret( + "DATABASE_URL", "postgresql://messenger:devpass@127.0.0.1:5432/messenger") + db_pool_min: int = _int("DB_POOL_MIN", 1) + db_pool_max: int = _int("DB_POOL_MAX", 10) # ограниченный пул + db_pool_timeout: float = _float("DB_POOL_TIMEOUT", 3.0) # ждать свободное соединение + db_connect_timeout: int = _int("DB_CONNECT_TIMEOUT", 3) + db_statement_timeout_ms: int = _int("DB_STATEMENT_TIMEOUT_MS", 5000) + migrate_on_start: bool = os.getenv("MIGRATE_ON_START", "true").lower() == "true" + + # Одновременных вычислений Argon2id на реплику (каждое ≈ 64 МиБ RAM). + password_hash_concurrency: int = _int("PASSWORD_HASH_CONCURRENCY", 2) + + # Сессии + session_ttl_seconds: int = _int("SESSION_TTL_SECONDS", 3600) + + # Идемпотентность POST сообщений: сколько хранить ключ (контракт: 24 часа) + idempotency_ttl_seconds: int = _int("IDEMPOTENCY_TTL_SECONDS", 86400) + + # Redis/Valkey — кэш сессий (не источник истины). Пусто = кэш выключен. + # Имя из skeleton — CACHE_URL(_FILE); REDIS_URL оставлено как синоним. + redis_url: str = _secret("CACHE_URL") or _secret("REDIS_URL") + redis_timeout: float = _float("REDIS_TIMEOUT", 0.5) + session_cache_ttl_seconds: int = _int("SESSION_CACHE_TTL_SECONDS", 60) + + # lab4: S3-совместимое хранилище (MinIO) — только байты вложений. + # API ходит отдельным пользователем с правами только на свой bucket + # (не root MinIO): S3_ACCESS_KEY_ID(_FILE) / S3_SECRET_ACCESS_KEY(_FILE). + s3_endpoint: str = os.getenv("S3_ENDPOINT", "http://s3:9000") + s3_region: str = os.getenv("S3_REGION", "us-east-1") + s3_bucket: str = os.getenv("S3_BUCKET", "messenger-attachments") + s3_access_key_id: str = _secret("S3_ACCESS_KEY_ID") + s3_secret_access_key: str = _secret("S3_SECRET_ACCESS_KEY") + s3_connect_timeout: float = _float("S3_CONNECT_TIMEOUT", 2.0) + s3_read_timeout: float = _float("S3_READ_TIMEOUT", 10.0) + s3_max_attempts: int = _int("S3_MAX_ATTEMPTS", 2) + # Сколько секунд после ошибки соединения с S3 сразу отвечать 503 (circuit breaker). + s3_breaker_seconds: float = _float("S3_BREAKER_SECONDS", 5.0) + + # Лимиты загрузки (контракт: 10 MiB и 40 млн пикселей). + max_upload_bytes: int = _int("MAX_UPLOAD_BYTES", 10 * 1024 * 1024) + max_image_pixels: int = _int("MAX_IMAGE_PIXELS", 40_000_000) + # Сколько ждать тело запроса целиком (защита от «медленной» загрузки). + upload_body_timeout_seconds: float = _float("UPLOAD_BODY_TIMEOUT_SECONDS", 60.0) + # Сколько байт тела держим в RAM; остальное — во временном файле, + # который удаляется сразу после ответа (не хранилище, только буфер). + upload_spool_memory_bytes: int = _int("UPLOAD_SPOOL_MEMORY_BYTES", 256 * 1024) + # Одновременных загрузок на реплику и одновременных проверок изображения. + upload_max_concurrent: int = _int("UPLOAD_MAX_CONCURRENT", 16) + image_check_concurrency: int = _int("IMAGE_CHECK_CONCURRENCY", 2) + + # Очистка «сирот» (объект в S3 без метаданных в БД). + # Журнал upload_intents старше grace period считается брошенным. + upload_grace_seconds: int = _int("UPLOAD_GRACE_SECONDS", 900) + janitor_interval_seconds: int = _int("JANITOR_INTERVAL_SECONDS", 60) + janitor_enabled: bool = os.getenv("JANITOR_ENABLED", "true").lower() == "true" + + # Внедрение отказов ТОЛЬКО для тестового профиля fault (api-fault). + # В обычных репликах выключено: заголовок X-Fault-Inject игнорируется. + fault_injection: bool = os.getenv("FAULT_INJECTION", "false").lower() == "true" + + +settings = Settings() diff --git a/app/db.py b/app/db.py new file mode 100644 index 00000000..3a3368e1 --- /dev/null +++ b/app/db.py @@ -0,0 +1,50 @@ +""" +Пул соединений с PostgreSQL. + +- Пул ограничен (DB_POOL_MAX): при нагрузке запросы ждут свободное соединение + не дольше DB_POOL_TIMEOUT, а не открывают соединения без предела. +- connect_timeout и statement_timeout: зависший запрос или недоступная БД + не держат обработчик бесконечно — клиент получает 503. +- Все запросы параметризованы (%s), SQL-инъекция невозможна. +""" +from __future__ import annotations +from psycopg_pool import AsyncConnectionPool + +from .config import settings + +pool: AsyncConnectionPool | None = None + + +def make_pool() -> AsyncConnectionPool: + return AsyncConnectionPool( + conninfo=settings.database_url, + min_size=settings.db_pool_min, + max_size=settings.db_pool_max, + timeout=settings.db_pool_timeout, + kwargs={ + "connect_timeout": settings.db_connect_timeout, + "options": f"-c statement_timeout={settings.db_statement_timeout_ms}", + "application_name": "messenger-api", + }, + # Перед выдачей соединение проверяется (SELECT 1 на уровне протокола): + # после рестарта PostgreSQL «мёртвые» соединения отбрасываются, а не дают 503. + check=AsyncConnectionPool.check_connection, + open=False, + ) + + +async def open_pool() -> None: + global pool + pool = make_pool() + # wait=False: API стартует, даже если БД ещё поднимается; /health/ready это покажет. + await pool.open(wait=False) + + +async def close_pool() -> None: + if pool is not None: + await pool.close() + + +def get_pool() -> AsyncConnectionPool: + assert pool is not None, "pool is not opened" + return pool diff --git a/app/images.py b/app/images.py new file mode 100644 index 00000000..35db74ec --- /dev/null +++ b/app/images.py @@ -0,0 +1,235 @@ +""" +Проверка загруженного изображения ПО СОДЕРЖИМОМУ (lab4). + +Порядок важен: сначала дешёвые проверки, потом дорогие. + 1. Сигнатура (magic bytes) → реальный тип. Не PNG/JPEG или не совпадает + с заявленным Content-Type → 415 (подмена MIME). + 2. Размеры из заголовка (PNG IHDR / JPEG SOF) → width × height ≤ MAX_IMAGE_PIXELS, + иначе 413. Это делается ДО распаковки пикселей: «декомпрессионная бомба» + (маленький файл, огромная картинка) отсекается, не заняв память. + 3. Целостность → повреждённый файл даёт 415: + - PNG: потоково читаем чанки, сверяем CRC каждого, распаковываем IDAT + кусками по 64 КиБ и только СЧИТАЕМ байты (пиксели не храним). + Объём распакованных данных должен ровно совпасть с тем, что следует + из IHDR; лишнее сверх ожидаемого не распаковываем вообще. + - JPEG: Pillow в режиме draft (декодирование в масштабе 1/8) — + весь поток проверяется декодером, а памяти нужно в ~64 раза меньше. +Памяти на проверку: O(64 КиБ) для PNG и ~(пиксели/64)×3 байт для JPEG, +независимо от размера файла. +""" +from __future__ import annotations + +import struct +import warnings +import zlib +from dataclasses import dataclass +from typing import BinaryIO + +from PIL import Image, ImageFile + +PNG_SIG = b"\x89PNG\r\n\x1a\n" +JPEG_SIG = b"\xff\xd8\xff" +CHUNK = 64 * 1024 + +# Усечённый файл — ошибка, а не «догрузим серым». +ImageFile.LOAD_TRUNCATED_IMAGES = False +# Предупреждение Pillow о «бомбе» превращаем в исключение (→ 413), а не в строку лога. +warnings.simplefilter("error", Image.DecompressionBombWarning) + + +class ImageTooLarge(Exception): + """Слишком много пикселей → 413.""" + + +class BadImage(Exception): + """Не PNG/JPEG, тип не совпадает с Content-Type или файл повреждён → 415.""" + + +@dataclass(frozen=True) +class ImageInfo: + content_type: str + width: int + height: int + + +def sniff(head: bytes) -> str | None: + """Реальный тип по первым байтам. Расширение и заголовок клиента не учитываются.""" + if head.startswith(PNG_SIG): + return "image/png" + if head.startswith(JPEG_SIG): + return "image/jpeg" + return None + + +def inspect(f: BinaryIO, declared_type: str, max_pixels: int) -> ImageInfo: + """Проверить файл (seekable) и вернуть реальный тип и размеры. + Бросает ImageTooLarge или BadImage. Блокирующая: вызывать в пуле потоков.""" + f.seek(0) + actual = sniff(f.read(16)) + if actual is None: + raise BadImage("not a PNG or JPEG") + if actual != declared_type: + raise BadImage("content does not match Content-Type") + f.seek(0) + try: + if actual == "image/png": + w, h = _check_png(f, max_pixels) + else: + w, h = _check_jpeg(f, max_pixels) + except (ImageTooLarge, BadImage): + raise + except (zlib.error, struct.error, ValueError, OSError, EOFError, IndexError) as exc: + # Любая ошибка разбора содержимого клиента — это битый файл (415), а не 500. + raise BadImage("corrupt image data") from exc + return ImageInfo(actual, w, h) + + +# --------------------------------------------------------------------- PNG +# color type → число каналов; допустимые глубины цвета (спецификация PNG, 11.2.2) +_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: (x0, y0, dx, dy) семи проходов +_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)) + + +def _png_layout(w: int, h: int, bits_per_pixel: int, interlaced: bool) -> list[tuple[int, int]]: + """Список (число строк, длина строки с байтом фильтра) для всех проходов.""" + def stride(width: int) -> int: + return 1 + (width * bits_per_pixel + 7) // 8 + + if not interlaced: + return [(h, stride(w))] + out = [] + for x0, y0, dx, dy in _ADAM7: + pw = (w - x0 + dx - 1) // dx if w > x0 else 0 + ph = (h - y0 + dy - 1) // dy if h > y0 else 0 + if pw and ph: + out.append((ph, stride(pw))) + return out + + +def _read_exact(f: BinaryIO, n: int) -> bytes: + data = f.read(n) + if len(data) != n: + raise BadImage("truncated PNG") + return data + + +def _check_png(f: BinaryIO, max_pixels: int) -> tuple[int, int]: + if f.read(8) != PNG_SIG: + raise BadImage("bad PNG signature") + width = height = 0 + layout: list[tuple[int, int]] = [] + expected = produced = 0 + seg = row_left = 0 # позиция для проверки байтов фильтра строк + inflater = None + seen_ihdr = seen_plte = seen_idat = seen_iend = False + color_type = 0 + + def consume(raw: bytes) -> None: + """Учесть распакованные байты: длина и байт фильтра в начале каждой строки.""" + nonlocal produced, seg, row_left + produced += len(raw) + if produced > expected: + raise BadImage("PNG image data is longer than declared") + pos = 0 + while pos < len(raw): + if row_left == 0: # начало новой строки: байт фильтра 0..4 + if raw[pos] > 4: + raise BadImage("bad PNG filter type") + rows, stride = layout[seg] + layout[seg] = (rows - 1, stride) + if layout[seg][0] == 0: + seg += 1 + row_left = stride + take = min(row_left, len(raw) - pos) + row_left -= take + pos += take + + def feed(data: bytes) -> None: + """Распаковать порциями ≤64 КиБ: бомба внутри IDAT не займёт память. + Цикл продолжается, пока zlib отдаёт полный буфер (могут остаться данные).""" + while True: + out = inflater.decompress(data, CHUNK) + consume(out) + data = inflater.unconsumed_tail + if inflater.eof or (not data and len(out) < CHUNK): + return + + while not seen_iend: + length, ctype = struct.unpack(">I4s", _read_exact(f, 8)) + if length > 0x7FFFFFFF or not ctype.isalpha(): + raise BadImage("bad PNG chunk") + crc = zlib.crc32(ctype) + if not seen_ihdr and ctype != b"IHDR": + raise BadImage("PNG must start with IHDR") + + if ctype == b"IHDR": + if seen_ihdr or length != 13: + raise BadImage("bad IHDR") + data = _read_exact(f, 13) + crc = zlib.crc32(data, crc) + width, height, depth, color_type, comp, filt, interlace = struct.unpack(">IIBBBBB", data) + if width == 0 or height == 0 or width > 0x7FFFFFFF or height > 0x7FFFFFFF: + raise BadImage("bad PNG dimensions") + # Лимит пикселей — ДО распаковки данных. + if width * height > max_pixels: + raise ImageTooLarge(f"{width}x{height} exceeds pixel limit") + if color_type not in _PNG_CHANNELS or depth not in _PNG_DEPTHS[color_type] \ + or comp != 0 or filt != 0 or interlace not in (0, 1): + raise BadImage("unsupported PNG header") + layout = _png_layout(width, height, depth * _PNG_CHANNELS[color_type], interlace == 1) + expected = sum(rows * stride for rows, stride in layout) + inflater = zlib.decompressobj() + seen_ihdr = True + else: + left = length + while left: + part = _read_exact(f, min(CHUNK, left)) + left -= len(part) + crc = zlib.crc32(part, crc) + if ctype == b"IDAT": + if inflater is None or inflater.eof: + raise BadImage("unexpected PNG data") + feed(part) + if ctype == b"IDAT": + seen_idat = True + elif ctype == b"PLTE": + seen_plte = True + elif ctype == b"IEND": + seen_iend = True + stored_crc = struct.unpack(">I", _read_exact(f, 4))[0] + if stored_crc != crc & 0xFFFFFFFF: + raise BadImage("PNG CRC mismatch") + + if not seen_idat or inflater is None: + raise BadImage("PNG has no image data") + if color_type == 3 and not seen_plte: + raise BadImage("palette PNG without PLTE") + if not inflater.eof or produced != expected: + raise BadImage("PNG image data is incomplete") + return width, height + + +# -------------------------------------------------------------------- JPEG +def _check_jpeg(f: BinaryIO, max_pixels: int) -> tuple[int, int]: + # Страховка Pillow от бомб; основной лимит проверяем сами ниже. + Image.MAX_IMAGE_PIXELS = max_pixels + try: + with Image.open(f, formats=["JPEG"]) as img: # читает только заголовок + width, height = img.size + if width <= 0 or height <= 0: + raise BadImage("bad JPEG dimensions") + if width * height > max_pixels: + raise ImageTooLarge(f"{width}x{height} exceeds pixel limit") + # Декодируем весь поток в масштабе 1/8: битый/усечённый файл даст ошибку, + # а памяти нужно (W/8)×(H/8)×3 байт вместо W×H×3. + img.draft("RGB", (max(1, width // 8), max(1, height // 8))) + img.load() + except (Image.DecompressionBombError, Image.DecompressionBombWarning) as exc: + raise ImageTooLarge("pixel limit") from exc + except (ImageTooLarge, BadImage): + raise + except (OSError, SyntaxError, ValueError, struct.error, EOFError, IndexError) as exc: + raise BadImage("corrupt JPEG") from exc + return width, height diff --git a/app/janitor.py b/app/janitor.py new file mode 100644 index 00000000..40fa4bd2 --- /dev/null +++ b/app/janitor.py @@ -0,0 +1,177 @@ +""" +Очистка «сирот» после сбоев между S3 и PostgreSQL (lab4, уровень 4). + +Протокол загрузки (app/main.py → upload_attachment): + 1. INSERT upload_intents(object_key) + COMMIT ← намерение записано + 2. PUT объекта в S3 + 3. BEGIN; DELETE upload_intents …; INSERT attachments …; COMMIT ← 201 только после этого +Если 2 или 3 не удались — API сразу компенсирует (удаляет объект и строку журнала). +Если компенсация не удалась или процесс упал (kill -9, OOM, рестарт контейнера) — +в журнале остаётся строка без метаданных. Её и обрабатывает janitor: + + строка upload_intents СТАРШЕ grace period → + BEGIN; DELETE строку (блокировка); DELETE объект в S3; COMMIT + - ошибка S3 → ROLLBACK, строка остаётся, повтор на следующем проходе; + - упали после DELETE в S3, до COMMIT → строка остаётся, повторное + удаление объекта безопасно (DELETE в S3 идемпотентен). + +Почему grace period безопасен: живая загрузка не может длиться дольше +UPLOAD_BODY_TIMEOUT_SECONDS (60 c) + таймауты S3/БД (~30 c). По умолчанию +UPLOAD_GRACE_SECONDS = 900 c (15 мин) — в 10 раз больше. Даже если +загрузка «проспала» grace period, шаг 3 удаляет строку журнала в той же +транзакции, что и INSERT метаданных: если janitor уже забрал строку, загрузка +получит 0 строк, откатится и ответит 503 — 201 на удалённый объект невозможен. +Готовые вложения (есть строка в attachments) janitor не трогает никогда. + +Страховка (--scan-bucket): обход bucket по prefix originals/ — объект старше +grace period, для которого нет ни attachments, ни upload_intents, — сирота. + +Запуск: + - в каждой реплике API фоновым циклом (JANITOR_INTERVAL_SECONDS), но + одновременно работает только одна: pg_try_advisory_lock; + - вручную: python -m app.janitor --once [--dry-run] [--scan-bucket] [--grace-seconds N] +""" +from __future__ import annotations + +import argparse +import asyncio +import json +import logging +import random +import time +from datetime import datetime, timedelta, timezone + +import psycopg +from fastapi.concurrency import run_in_threadpool + +from . import db, storage +from .config import settings + +log = logging.getLogger("messenger.janitor") +LOCK_ID = 824_113_2027 +BATCH = 500 + + +async def _sweep_intents(conn, grace: int, dry_run: bool, stats: dict) -> None: + cur = await conn.execute( + "SELECT object_key FROM upload_intents " + "WHERE created_at < now() - make_interval(secs => %s) ORDER BY created_at LIMIT %s", + (grace, BATCH)) + keys = [r[0] for r in await cur.fetchall()] + for key in keys: + stats["intents_expired"] += 1 + try: + async with conn.transaction(): + cur = await conn.execute( + "DELETE FROM upload_intents WHERE object_key = %s " + "AND created_at < now() - make_interval(secs => %s) RETURNING 1", (key, grace)) + if await cur.fetchone() is None: + continue # загрузка успела завершиться — не наше + cur = await conn.execute("SELECT 1 FROM attachments WHERE object_key = %s", (key,)) + committed = await cur.fetchone() is not None + if dry_run: + stats["would_delete_objects"] += 0 if committed else 1 + raise psycopg.Rollback() + if not committed: + await storage.delete(key) # ошибка → ROLLBACK, строка останется + stats["objects_deleted"] += 1 + stats["intents_removed"] += 1 + except storage.StorageUnavailable: + stats["errors"] += 1 + log.warning("janitor: s3 unavailable, will retry later") + return + + +async def _scan_bucket(conn, grace: int, dry_run: bool, stats: dict) -> None: + cutoff = datetime.now(timezone.utc) - timedelta(seconds=grace) + + def old_keys() -> list[str]: + return [k for k, modified, _ in storage.list_sync() if modified < cutoff] + + try: + candidates = await run_in_threadpool(old_keys) + except storage.StorageUnavailable: + stats["errors"] += 1 + return + stats["objects_scanned"] = len(candidates) + for i in range(0, len(candidates), BATCH): + part = candidates[i:i + BATCH] + cur = await conn.execute( + "SELECT object_key FROM attachments WHERE object_key = ANY(%s) " + "UNION SELECT object_key FROM upload_intents WHERE object_key = ANY(%s)", (part, part)) + known = {r[0] for r in await cur.fetchall()} + for key in part: + if key in known: + continue + stats["orphans_found"] += 1 + if dry_run: + continue + try: + await storage.delete(key) + stats["objects_deleted"] += 1 + except storage.StorageUnavailable: + stats["errors"] += 1 + return + + +async def run_once(grace: int | None = None, dry_run: bool = False, + scan_bucket: bool = False) -> dict: + grace = settings.upload_grace_seconds if grace is None else grace + stats = {"grace_seconds": grace, "dry_run": dry_run, "locked": False, + "intents_expired": 0, "intents_removed": 0, "objects_deleted": 0, + "would_delete_objects": 0, "orphans_found": 0, "errors": 0} + started = time.monotonic() + async with db.get_pool().connection() as conn: + await conn.set_autocommit(True) + cur = await conn.execute("SELECT pg_try_advisory_lock(%s)", (LOCK_ID,)) + if not (await cur.fetchone())[0]: + return stats # другая реплика уже чистит + stats["locked"] = True + try: + await _sweep_intents(conn, grace, dry_run, stats) + if scan_bucket: + await _scan_bucket(conn, grace, dry_run, stats) + finally: + await conn.execute("SELECT pg_advisory_unlock(%s)", (LOCK_ID,)) + await conn.set_autocommit(False) + stats["duration_ms"] = round((time.monotonic() - started) * 1000, 1) + return stats + + +async def loop_forever() -> None: + """Фоновый цикл в реплике API. Ошибки логируются, цикл не падает.""" + runs = 0 + while True: + # Случайный сдвиг: реплики не стучатся в advisory lock одновременно. + await asyncio.sleep(settings.janitor_interval_seconds * random.uniform(0.8, 1.2)) + runs += 1 + try: + stats = await run_once(scan_bucket=(runs % 60 == 0)) # обход bucket — примерно раз в час + if stats["intents_removed"] or stats["objects_deleted"] or stats["errors"]: + log.info("janitor: %s", stats) + except asyncio.CancelledError: + raise + except Exception as exc: # noqa: BLE001 — фоновая задача не должна умирать + log.warning("janitor run failed: %s", type(exc).__name__) + + +async def _cli() -> None: + ap = argparse.ArgumentParser(description="cleanup of orphan S3 objects") + ap.add_argument("--once", action="store_true", help="один проход (по умолчанию)") + ap.add_argument("--dry-run", action="store_true", help="только показать, ничего не удалять") + ap.add_argument("--scan-bucket", action="store_true", help="дополнительно обойти bucket") + ap.add_argument("--grace-seconds", type=int, default=None) + args = ap.parse_args() + await db.open_pool() + storage.init() + try: + await db.get_pool().wait(timeout=10) + stats = await run_once(args.grace_seconds, args.dry_run, args.scan_bucket) + finally: + await db.close_pool() + print(json.dumps(stats, ensure_ascii=False)) + + +if __name__ == "__main__": + logging.basicConfig(level=logging.INFO) + asyncio.run(_cli()) diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..3d66f894 --- /dev/null +++ b/app/main.py @@ -0,0 +1,598 @@ +""" +HTTP-слой мессенджера (lab4). + +Клиент → LB (HAProxy) → эта реплика API (их ≥2, взаимозаменяемы) + → PostgreSQL (источник истины: данные и метаданные вложений) + → Redis (общий кэш сессий) + → MinIO, приватный bucket (только байты вложений) + +lab2: пароль Argon2id, вход Basic → Bearer-сессия в PostgreSQL, X-User-Id игнорируется. +lab3: X-Instance-Id в каждом ответе; POST сообщения требует Idempotency-Key, + идемпотентность общая для всех реплик (таблица idempotency_keys); + у реплики нет локального состояния, от которого зависит корректность. +lab4: вложения PNG/JPEG: POST /chats/{id}/attachments (сырые байты, 201 ready), + GET /attachments/{id} и /content (только участникам чата), attachment_ids в сообщениях. +""" +from __future__ import annotations +import asyncio +import base64 +import binascii +import contextlib +import logging +import os +import re +import time +import uuid +from contextlib import asynccontextmanager + +import psycopg +from fastapi import Depends, FastAPI, Header, Query, Request +from fastapi.concurrency import run_in_threadpool +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse, Response, StreamingResponse +from psycopg_pool import PoolTimeout +from pydantic import BaseModel, Field, field_validator, model_validator +from starlette.exceptions import HTTPException as StarletteHTTPException + +from urllib.parse import quote + +from . import db, images, janitor, repo, security, sessions, storage, uploads +from .config import settings +from .migrate import migrate + +logger = logging.getLogger("messenger") + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") +IDEMPOTENCY_KEY_RE = re.compile(r"[A-Za-z0-9._:-]{1,128}") +BEARER_CHALLENGE = 'Bearer realm="messenger"' +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' +MAX_ATTACHMENTS_PER_MESSAGE = 10 +KNOWN_VARIANTS = ("thumbnail", "crop", "optimized") # появятся в lab5 + + +@asynccontextmanager +async def lifespan(app: FastAPI): + if settings.migrate_on_start: + try: + applied = await migrate() + logger.info("migrations: %s", applied or "up to date") + except psycopg.OperationalError as exc: + # БД ещё не готова: API всё равно стартует, /health/ready покажет 503. + logger.warning("migrations skipped, database unavailable: %s", type(exc).__name__) + await db.open_pool() + sessions.init_redis() + storage.init() + cleaner = asyncio.create_task(janitor.loop_forever()) if settings.janitor_enabled else None + yield + if cleaner is not None: + cleaner.cancel() + with contextlib.suppress(asyncio.CancelledError): + await cleaner + await sessions.close_redis() + await db.close_pool() + + +app = FastAPI(title="MTUSI Messenger — lab4", lifespan=lifespan) + + +# ============================================================================ +# 1. ЕДИНЫЙ ФОРМАТ ОШИБОК {"error":{"code","message","request_id"}} +# ============================================================================ +class ApiError(Exception): + def __init__(self, status: int, code: str, message: str, headers: dict | None = None): + self.status, self.code, self.message, self.headers = status, code, message, headers or {} + + +def error_response(request: Request, status: int, code: str, message: str, + headers: dict | None = None) -> JSONResponse: + rid = getattr(request.state, "request_id", str(uuid.uuid4())) + return JSONResponse( + status_code=status, + content={"error": {"code": code, "message": message, "request_id": rid}}, + headers={"X-Request-Id": rid, "X-Instance-Id": settings.instance_id, **(headers or {})}, + ) + + +@app.exception_handler(ApiError) +async def handle_api_error(request: Request, exc: ApiError): + return error_response(request, exc.status, exc.code, exc.message, exc.headers) + + +@app.exception_handler(RequestValidationError) +async def handle_validation(request: Request, exc: RequestValidationError): + return error_response(request, 400, "invalid_request", "invalid request body or parameters") + + +@app.exception_handler(StarletteHTTPException) +async def handle_http(request: Request, exc: StarletteHTTPException): + # Только коды из enum контракта (contracts/openapi.json → Error.code). + code = {401: "unauthorized", 404: "not_found", 409: "conflict", + 413: "payload_too_large", 415: "unsupported_media_type", + 429: "rate_limited", 503: "unavailable"}.get( + exc.status_code, "internal_error" if exc.status_code >= 500 else "invalid_request") + return error_response(request, exc.status_code, code, str(exc.detail)) + + +@app.exception_handler(psycopg.OperationalError) +@app.exception_handler(PoolTimeout) +async def handle_db_down(request: Request, exc: Exception): + # БД недоступна или не ответила за таймаут: ограниченная ошибка, а не зависание. + logger.warning("database unavailable: %s", type(exc).__name__) + return error_response(request, 503, "unavailable", "service temporarily unavailable") + + +@app.exception_handler(storage.StorageUnavailable) +async def handle_storage_down(request: Request, exc: Exception): + # S3 недоступен/не ответил за таймаут: 503, текстовая часть мессенджера продолжает работать. + return error_response(request, 503, "unavailable", "file storage temporarily unavailable") + + +@app.exception_handler(uploads.UploadError) +async def handle_upload_error(request: Request, exc: uploads.UploadError): + return error_response(request, exc.status, exc.code, exc.message) + + +@app.exception_handler(Exception) +async def handle_unexpected(request: Request, exc: Exception): + logger.exception("unexpected error") + return error_response(request, 500, "internal_error", "internal error") + + +# ============================================================================ +# 2. X-Request-Id, X-Instance-Id + лог без тела запроса, токенов и паролей +# ============================================================================ +@app.middleware("http") +async def add_request_id(request: Request, call_next): + rid = str(uuid.uuid4()) + request.state.request_id = rid + start = time.monotonic() + response = await call_next(request) + response.headers["X-Request-Id"] = rid + response.headers["X-Instance-Id"] = settings.instance_id # какая реплика ответила + logger.info("rid=%s %s %s -> %s %sms", rid, request.method, request.url.path, + response.status_code, round((time.monotonic() - start) * 1000, 1)) + return response + + +# ============================================================================ +# 3. АУТЕНТИФИКАЦИЯ +# Bearer — для всех бизнес-запросов. Basic — только на POST /auth/sessions. +# X-User-Id больше ничего не значит и ни на что не влияет. +# ============================================================================ +def unauthorized(message: str = "invalid or missing bearer token") -> ApiError: + return ApiError(401, "unauthorized", message, {"WWW-Authenticate": BEARER_CHALLENGE}) + + +def _bearer_token(request: Request) -> str: + auth = request.headers.get("authorization", "") + scheme, _, token = auth.partition(" ") + token = token.strip() + if scheme.lower() != "bearer" or not token or len(token) > 512: + raise unauthorized() + return token + + +async def current_user(request: Request) -> dict: + """Зависимость FastAPI: выполняется ДО разбора тела → сначала 401, потом 400.""" + token = _bearer_token(request) + user = await sessions.resolve(db.get_pool(), token, repo.get_user) + if user is None: + raise unauthorized() + request.state.token = token + return user + + +def _parse_basic(request: Request) -> tuple[str, str]: + bad = ApiError(401, "unauthorized", "invalid credentials", {"WWW-Authenticate": BASIC_CHALLENGE}) + scheme, _, value = request.headers.get("authorization", "").partition(" ") + if scheme.lower() != "basic" or not value: + raise bad + try: + decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8") + except (binascii.Error, UnicodeDecodeError): + raise bad + username, sep, password = decoded.partition(":") # двоеточие в пароле допустимо + if not sep or not username.isascii() or not (12 <= len(password) <= 128): + raise bad + return username, password + + +def require_json(request: Request) -> None: + """Тип тела проверяем ДО валидации тела: не JSON → 415, а не 400. + Подключается после current_user, поэтому без токена по-прежнему сначала 401. + Параметры вроде '; charset=utf-8' допустимы.""" + media_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower() + if media_type != "application/json": + raise ApiError(415, "unsupported_media_type", "Content-Type must be application/json") + + +_kdf_slots: asyncio.Semaphore | None = None + + +async def kdf(fn, *args): + """Argon2id по умолчанию берёт 64 МиБ RAM на один хэш. Без ограничения 20 + одновременных регистраций/входов на реплике = >1 ГиБ и OOM-kill контейнера + с лимитом 256 МиБ. Поэтому одновременно считаем не больше + PASSWORD_HASH_CONCURRENCY хэшей, остальные ждут в очереди.""" + global _kdf_slots + if _kdf_slots is None: + _kdf_slots = asyncio.Semaphore(settings.password_hash_concurrency) + async with _kdf_slots: + return await run_in_threadpool(fn, *args) + + +# ============================================================================ +# 4. МОДЕЛИ ВВОДА +# ============================================================================ +class CreateUser(BaseModel): + model_config = {"extra": "forbid"} + username: str + display_name: str + password: str + + @field_validator("username") + @classmethod + def check_username(cls, v: str) -> str: + if not USERNAME_RE.match(v): + raise ValueError("username must match [a-z0-9_]{3,32}") + return v + + @field_validator("display_name") + @classmethod + def check_display_name(cls, v: str) -> str: + if not (1 <= len(v) <= 100) or not v.strip(): + raise ValueError("display_name must be 1..100 non-blank chars") + return v + + @field_validator("password") + @classmethod + def check_password(cls, v: str) -> str: + if not (12 <= len(v) <= 128) or not v.strip(): + raise ValueError("password must be 12..128 chars") + return v + + +class CreateChat(BaseModel): + model_config = {"extra": "forbid"} + title: str + member_ids: list[str] + + @field_validator("title") + @classmethod + def check_title(cls, v: str) -> str: + if not (1 <= len(v) <= 100) or not v.strip(): + raise ValueError("title must be 1..100 non-blank chars") + return v + + +class CreateMessage(BaseModel): + model_config = {"extra": "forbid"} + text: str + # lab4: 0–10 уникальных id вложений этого чата; отсутствие поля == []. + attachment_ids: list[str] = Field(default_factory=list) + + @field_validator("text") + @classmethod + def check_text(cls, v: str) -> str: + if len(v) > 4000: + raise ValueError("text must be at most 4000 chars") + return v + + @field_validator("attachment_ids") + @classmethod + def check_attachment_ids(cls, v: list[str]) -> list[str]: + if len(v) > MAX_ATTACHMENTS_PER_MESSAGE: + raise ValueError("at most 10 attachment_ids") + if len(set(v)) != len(v): + raise ValueError("attachment_ids must be unique") + return v + + @model_validator(mode="after") + def text_or_attachments(self): + # Пустой/пробельный текст допустим только вместе с вложениями. + if not self.attachment_ids and not self.text.strip(): + raise ValueError("text must be non-blank when there are no attachments") + return self + + +def parse_uuid(value: str, what: str) -> uuid.UUID: + try: + return uuid.UUID(value) + except ValueError: + raise ApiError(400, "invalid_request", f"{what} is not a valid uuid") + + +# ============================================================================ +# 5. ENDPOINTS +# ============================================================================ +@app.get("/health/live") +async def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready") +async def health_ready(request: Request): + # Критичная зависимость — только PostgreSQL. Redis — кэш: его отказ не делает API неготовым. + try: + async with db.get_pool().connection() as conn: + await conn.execute("SELECT 1 FROM schema_migrations LIMIT 1") + except (psycopg.Error, PoolTimeout): + return error_response(request, 503, "unavailable", "database is not ready") + return {"status": "ok"} + + +# -------- users и сессии -------- +@app.post("/api/v1/users", status_code=201) +async def create_user(body: CreateUser, _json: None = Depends(require_json)): + # Argon2 намеренно медленный — считаем в пуле потоков, чтобы не блокировать event loop. + password_hash = await kdf(security.hash_password, body.password) + async with db.get_pool().connection() as conn: + try: + return await repo.create_user(conn, body.username, body.display_name, password_hash) + except repo.UsernameTaken: + raise ApiError(409, "conflict", "username already taken") + + +@app.post("/api/v1/auth/sessions", status_code=201) +async def create_session(request: Request): + username, password = _parse_basic(request) + async with db.get_pool().connection() as conn: + row = await repo.get_credentials(conn, username) + stored_hash = row[4] if row else None + # Проверяем хэш даже для несуществующего пользователя — одинаковое время ответа. + ok = await kdf(security.verify_password, stored_hash, password) + if not ok: + raise ApiError(401, "unauthorized", "invalid credentials", {"WWW-Authenticate": BASIC_CHALLENGE}) + user = repo.user_out(row) + async with db.get_pool().connection() as conn: + if security.needs_rehash(stored_hash): + await repo.update_password_hash(conn, row[0], await kdf(security.hash_password, password)) + token, expires_at = await sessions.create_session(conn, row[0]) + return {"token": token, "token_type": "Bearer", "expires_at": repo.iso(expires_at), "user": user} + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def delete_session(request: Request, user: dict = Depends(current_user)): + try: + revoked = await sessions.revoke(db.get_pool(), request.state.token) + except sessions.CacheUnavailable: + # 204 только при гарантированном отзыве; иначе ограниченная ошибка, повторить позже. + raise ApiError(503, "unavailable", "session cache unavailable, logout not confirmed") + if not revoked: + raise unauthorized() + return Response(status_code=204) + + +@app.get("/api/v1/users/me") +async def get_me(user: dict = Depends(current_user)): + return user + + +# -------- chats -------- +@app.post("/api/v1/chats", status_code=201) +async def create_chat(body: CreateChat, user: dict = Depends(current_user), + _json: None = Depends(require_json)): + members = body.member_ids + if not (1 <= len(members) <= 100): + raise ApiError(400, "invalid_request", "member_ids must have 1..100 items") + if len(set(members)) != len(members): + raise ApiError(400, "invalid_request", "duplicate member_ids") + ids = [parse_uuid(m, "member id") for m in members] + if uuid.UUID(user["id"]) not in ids: + raise ApiError(400, "invalid_request", "caller must be a member") + async with db.get_pool().connection() as conn: + # Одна транзакция: чат и все участники создаются вместе или не создаются вовсе. + async with conn.transaction(): + if await repo.count_existing_users(conn, ids) != len(ids): + raise ApiError(400, "invalid_request", "unknown member") + return await repo.insert_chat(conn, body.title, ids, user["id"]) + + +@app.get("/api/v1/chats") +async def list_chats(user: dict = Depends(current_user), + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = Query(default=None, min_length=1)): + async with db.get_pool().connection() as conn: + try: + items, nxt = await repo.list_chats(conn, user["id"], limit, cursor) + except ValueError: + raise ApiError(400, "invalid_request", "bad cursor") + return {"items": items, "next_cursor": nxt} + + +async def accessible_chat(conn, chat_id: str, user: dict) -> dict: + """Кривой UUID → 400. Чата нет ИЛИ ты не участник → одинаковый 404.""" + cid = parse_uuid(chat_id, "chat_id") + chat = await repo.get_chat_for_member(conn, cid, user["id"]) + if chat is None: + raise ApiError(404, "not_found", "chat not found") + return chat + + +@app.get("/api/v1/chats/{chat_id}") +async def get_chat(chat_id: str, user: dict = Depends(current_user)): + async with db.get_pool().connection() as conn: + return await accessible_chat(conn, chat_id, user) + + +# -------- messages -------- +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +async def send_message(chat_id: str, body: CreateMessage, user: dict = Depends(current_user), + _json: None = Depends(require_json), + idempotency_key: str | None = Header(default=None, alias="Idempotency-Key")): + # Ключ обязателен: без него клиент не может безопасно повторить запрос после таймаута. + if idempotency_key is None or not IDEMPOTENCY_KEY_RE.fullmatch(idempotency_key): + raise ApiError(400, "invalid_request", "Idempotency-Key header is required: [A-Za-z0-9._:-]{1,128}") + attachment_ids = [parse_uuid(a, "attachment_id") for a in body.attachment_ids] + if len(set(attachment_ids)) != len(attachment_ids): + raise ApiError(400, "invalid_request", "attachment_ids must be unique") + async with db.get_pool().connection() as conn: + # Повтор снова проверяет сессию (current_user) и доступ к чату. + chat = await accessible_chat(conn, chat_id, user) + try: + async with conn.transaction(): + # Отправитель — из сессии, а не из тела запроса. + return await repo.send_message_idempotent( + conn, chat["id"], user["id"], idempotency_key, body.text, + settings.idempotency_ttl_seconds, attachment_ids) + except repo.IdempotencyConflict: + raise ApiError(409, "conflict", "Idempotency-Key was already used with a different request") + except repo.AttachmentNotFound: + # Нет такого вложения ИЛИ оно из другого чата — одинаковый 404. + raise ApiError(404, "not_found", "attachment not found") + except repo.AttachmentNotReady: + raise ApiError(409, "conflict", "attachment is not usable") + + +@app.get("/api/v1/chats/{chat_id}/messages") +async def list_messages(chat_id: str, user: dict = Depends(current_user), + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = Query(default=None, min_length=1)): + async with db.get_pool().connection() as conn: + chat = await accessible_chat(conn, chat_id, user) + try: + items, nxt = await repo.list_messages(conn, chat["id"], limit, cursor) + except ValueError: + raise ApiError(400, "invalid_request", "bad cursor") + return {"items": items, "next_cursor": nxt} + + +# ============================================================================ +# 6. ВЛОЖЕНИЯ (lab4): байты — в приватном S3, метаданные — в PostgreSQL +# ============================================================================ +_upload_slots: asyncio.Semaphore | None = None +_image_checks: asyncio.Semaphore | None = None + + +def _slots() -> tuple[asyncio.Semaphore, asyncio.Semaphore]: + global _upload_slots, _image_checks + if _upload_slots is None: + _upload_slots = asyncio.Semaphore(settings.upload_max_concurrent) + _image_checks = asyncio.Semaphore(settings.image_check_concurrency) + return _upload_slots, _image_checks + + +async def _discard_upload(key: str) -> None: + """Компенсация: удалить объект и строку журнала. Если не вышло — + строка журнала останется, и объект удалит janitor после grace period.""" + try: + async with db.get_pool().connection() as conn: + async with conn.transaction(): + cur = await conn.execute( + "DELETE FROM upload_intents WHERE object_key = %s RETURNING 1", (key,)) + if await cur.fetchone() is not None: + await storage.delete(key) + except Exception as exc: # noqa: BLE001 — компенсация best effort + logger.warning("upload compensation failed, janitor will clean up: %s", type(exc).__name__) + + +def _fault(request: Request, point: str) -> None: + """Внедрение отказа для тестов уровня 4 — только при FAULT_INJECTION=true + (отдельная тестовая реплика api-fault). В обычных репликах — no-op.""" + if not settings.fault_injection or request.headers.get("x-fault-inject") != point: + return + logger.warning("FAULT INJECTION: %s", point) + if point == "crash-after-s3-put": + os._exit(1) # как kill -9: ни компенсации, ни COMMIT + raise RuntimeError("injected fault: " + point) + + +@app.post("/api/v1/chats/{chat_id}/attachments", status_code=201) +async def upload_attachment(chat_id: str, request: Request, user: dict = Depends(current_user), + filename: str | None = Query(default=None)): + # 1) доступ к чату → 2) имя → 3) заявленный тип → 4) заявленный размер; всё — до чтения тела. + async with db.get_pool().connection() as conn: + chat = await accessible_chat(conn, chat_id, user) + name = uploads.validate_filename(filename) + ctype = uploads.declared_type(request) + uploads.check_declared_length(request, settings.max_upload_bytes) + + slots, checks = _slots() + async with slots: # не больше N загрузок на реплику + body = await uploads.receive(request, settings.max_upload_bytes, + settings.upload_body_timeout_seconds, + settings.upload_spool_memory_bytes) + try: + async with checks: # CPU-тяжёлая проверка — ограниченно + try: + info = await run_in_threadpool(images.inspect, body.file, ctype, + settings.max_image_pixels) + except images.ImageTooLarge: + raise ApiError(413, "payload_too_large", "image has too many pixels") + except images.BadImage: + raise ApiError(415, "unsupported_media_type", + "file is not a valid image of the declared type") + + storage.ensure_available() # S3 заведомо недоступен → 503 без записи в журнал + attachment_id = uuid.uuid4() + key = storage.object_key(attachment_id) # ключ назначает сервер + async with db.get_pool().connection() as conn: + await repo.add_upload_intent(conn, key, attachment_id) # журнал ДО PUT + try: + await storage.put(key, body.file, body.size, info.content_type, + body.md5_b64, body.sha256_hex) + except storage.StorageUnavailable: + await _discard_upload(key) + raise + try: + _fault(request, "crash-after-s3-put") + _fault(request, "db-error-after-s3-put") + async with db.get_pool().connection() as conn: + async with conn.transaction(): + return await repo.commit_attachment( + conn, attachment_id=attachment_id, chat_id=chat["id"], + owner_id=user["id"], filename=name, content_type=info.content_type, + size_bytes=body.size, sha256=body.sha256_hex, + width=info.width, height=info.height, object_key=key) + except Exception as exc: + # PUT прошёл, COMMIT — нет: компенсируем сразу, 201 не отдаём. + logger.warning("attachment commit failed: %s", type(exc).__name__) + await _discard_upload(key) + raise ApiError(503, "unavailable", "attachment was not saved, retry later") + finally: + body.file.close() # буфер запроса удаляется всегда + + +async def accessible_attachment(conn, attachment_id: str, user: dict): + aid = parse_uuid(attachment_id, "attachment_id") + row = await repo.get_attachment_for_member(conn, aid, user["id"]) + if row is None: + # Нет вложения ИЛИ пользователь не участник его чата — одинаковый 404. + raise ApiError(404, "not_found", "attachment not found") + return row + + +@app.get("/api/v1/attachments/{attachment_id}") +async def get_attachment(attachment_id: str, user: dict = Depends(current_user)): + async with db.get_pool().connection() as conn: + return repo.attachment_out(await accessible_attachment(conn, attachment_id, user)) + + +@app.get("/api/v1/attachments/{attachment_id}/content") +async def download_attachment(attachment_id: str, user: dict = Depends(current_user), + variant: str = Query(default="original")): + parse_uuid(attachment_id, "attachment_id") + if variant != "original" and variant not in KNOWN_VARIANTS: + raise ApiError(400, "invalid_request", "unknown variant") + async with db.get_pool().connection() as conn: + row = await accessible_attachment(conn, attachment_id, user) + att = repo.attachment_out(row) + if att["status"] != "ready": + raise ApiError(409, "conflict", "attachment is not ready") + if variant != "original": + raise ApiError(404, "not_found", "variant not found") # вариантов в lab4 нет + try: + stream, length = await storage.open_object(row[11]) + except storage.ObjectMissing: + logger.error("object for attachment %s is missing in storage", att["id"]) + raise ApiError(500, "internal_error", "internal error") + headers = { + "Content-Length": str(length), + "ETag": f'"{att["sha256"]}"', + "Cache-Control": "private, no-cache", + "X-Content-Type-Options": "nosniff", + # filename только для отображения; RFC 5987 — любые символы безопасно закодированы. + "Content-Disposition": "inline; filename*=UTF-8''" + quote(att["filename"], safe=""), + } + # Байты идут из S3 клиенту кусками по 64 КиБ — файл целиком в RAM не загружается. + return StreamingResponse(storage.iter_body(stream), media_type=att["content_type"], headers=headers) diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 00000000..e52cec81 --- /dev/null +++ b/app/migrate.py @@ -0,0 +1,57 @@ +""" +Версионируемые миграции: migrations/NNNN_name.sql. + +- Таблица schema_migrations хранит применённые версии → повторный запуск + ничего не дублирует (идемпотентно). +- Каждая миграция применяется в своей транзакции: либо целиком, либо никак. +- pg_advisory_lock: если стартуют несколько API одновременно, миграции + выполнит только один, остальные подождут. + +Запуск вручную: python -m app.migrate +""" +from __future__ import annotations +import asyncio +import logging +from pathlib import Path + +import psycopg + +from .config import settings + +log = logging.getLogger("messenger.migrate") +MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations" +LOCK_ID = 824_113_2026 # произвольная константа для advisory lock + + +async def migrate(conninfo: str | None = None) -> list[str]: + applied_now: list[str] = [] + async with await psycopg.AsyncConnection.connect( + conninfo or settings.database_url, + connect_timeout=settings.db_connect_timeout, autocommit=True) as conn: + await conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,)) + try: + await conn.execute( + "CREATE TABLE IF NOT EXISTS schema_migrations (" + " version text PRIMARY KEY," + " applied_at timestamptz NOT NULL DEFAULT now())") + cur = await conn.execute("SELECT version FROM schema_migrations") + done = {row[0] for row in await cur.fetchall()} + for path in sorted(MIGRATIONS_DIR.glob("*.sql")): + version = path.stem + if version in done: + continue + async with conn.transaction(): + await conn.execute(path.read_text(encoding="utf-8")) + await conn.execute( + "INSERT INTO schema_migrations (version) VALUES (%s)", (version,)) + applied_now.append(version) + log.info("migration applied: %s", version) + finally: + await conn.execute("SELECT pg_advisory_unlock(%s)", (LOCK_ID,)) + return applied_now + + +if __name__ == "__main__": + logging.basicConfig(level=logging.INFO) + result = asyncio.run(migrate()) + print("applied:", result or "nothing (up to date)") diff --git a/app/repo.py b/app/repo.py new file mode 100644 index 00000000..a35093b0 --- /dev/null +++ b/app/repo.py @@ -0,0 +1,328 @@ +""" +Доступ к данным в PostgreSQL. Только параметризованные запросы (%s): +значения передаются отдельно от текста SQL, инъекция невозможна. +""" +from __future__ import annotations +import base64 +import hashlib +import json +import uuid +from datetime import datetime, timezone + +from psycopg.errors import UniqueViolation + + +def iso(dt: datetime) -> str: + """RFC 3339 UTC с Z — формат контракта.""" + return dt.astimezone(timezone.utc).isoformat().replace("+00:00", "Z") + + +def now() -> datetime: + return datetime.now(timezone.utc) + + +# ---------------------------------------------------------------- курсор +def encode_cursor(scope: str, created_at: datetime, id_) -> str: + raw = json.dumps({"s": scope, "c": iso(created_at), "i": str(id_)}).encode() + return base64.urlsafe_b64encode(raw).decode() + + +def decode_cursor(cursor: str, scope: str) -> tuple[datetime, uuid.UUID]: + """(created_at, id) последнего показанного элемента или ValueError → 400.""" + try: + data = json.loads(base64.urlsafe_b64decode(cursor.encode())) + if data.get("s") != scope: + raise ValueError("cursor scope mismatch") + return datetime.fromisoformat(data["c"].replace("Z", "+00:00")), uuid.UUID(data["i"]) + except (ValueError, KeyError, TypeError, AttributeError) as exc: + raise ValueError("bad cursor") from exc + + +def _page(rows: list, limit: int, scope: str, key): + """rows получены с LIMIT limit+1: лишняя строка = есть следующая страница.""" + has_more = len(rows) > limit + page = rows[:limit] + next_cursor = encode_cursor(scope, *key(page[-1])) if has_more and page else None + return page, next_cursor + + +# ---------------------------------------------------------------- users +USER_COLS = "id, username, display_name, created_at" + + +def user_out(row) -> dict: + return {"id": str(row[0]), "username": row[1], "display_name": row[2], "created_at": iso(row[3])} + + +class UsernameTaken(Exception): + pass + + +async def create_user(conn, username: str, display_name: str, password_hash: str) -> dict: + try: + cur = await conn.execute( + f"INSERT INTO users (id, username, display_name, password_hash, created_at) " + f"VALUES (%s, %s, %s, %s, %s) RETURNING {USER_COLS}", + (uuid.uuid4(), username, display_name, password_hash, now())) + except UniqueViolation as exc: + # Уникальность username гарантирует БД, а не проверка «есть ли такой» + # перед вставкой: две одновременные регистрации не пройдут обе. + raise UsernameTaken() from exc + return user_out(await cur.fetchone()) + + +async def get_user(conn, user_id) -> dict | None: + cur = await conn.execute(f"SELECT {USER_COLS} FROM users WHERE id = %s", (user_id,)) + row = await cur.fetchone() + return user_out(row) if row else None + + +async def get_credentials(conn, username: str): + cur = await conn.execute( + f"SELECT {USER_COLS}, password_hash FROM users WHERE username = %s", (username,)) + return await cur.fetchone() + + +async def update_password_hash(conn, user_id, password_hash: str) -> None: + await conn.execute("UPDATE users SET password_hash = %s WHERE id = %s", (password_hash, user_id)) + + +# ---------------------------------------------------------------- chats +CHAT_SELECT = ( + "SELECT c.id, c.title, c.created_at, " + " (SELECT array_agg(m.user_id ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) " + "FROM chats c ") + + +def chat_out(row) -> dict: + return {"id": str(row[0]), "title": row[1], + "member_ids": [str(x) for x in row[3]], "created_at": iso(row[2])} + + +async def count_existing_users(conn, ids: list[uuid.UUID]) -> int: + cur = await conn.execute("SELECT count(*) FROM users WHERE id = ANY(%s)", (ids,)) + return (await cur.fetchone())[0] + + +async def insert_chat(conn, title: str, member_ids: list[uuid.UUID], creator) -> dict: + """Чат + все участники. Вызывать внутри транзакции: либо всё, либо ничего.""" + chat_id, created = uuid.uuid4(), now() + await conn.execute( + "INSERT INTO chats (id, title, created_by, created_at) VALUES (%s, %s, %s, %s)", + (chat_id, title, creator, created)) + async with conn.cursor() as cur: + await cur.executemany( + "INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)", + [(chat_id, uid, pos) for pos, uid in enumerate(member_ids)]) + return {"id": str(chat_id), "title": title, + "member_ids": [str(x) for x in member_ids], "created_at": iso(created)} + + +async def get_chat_for_member(conn, chat_id, user_id) -> dict | None: + """Чат, если он существует И пользователь в нём состоит; иначе None (→ 404).""" + cur = await conn.execute( + CHAT_SELECT + "WHERE c.id = %s AND EXISTS " + "(SELECT 1 FROM chat_members x WHERE x.chat_id = c.id AND x.user_id = %s)", + (chat_id, user_id)) + row = await cur.fetchone() + return chat_out(row) if row else None + + +async def list_chats(conn, user_id, limit: int, cursor: str | None): + scope = f"chats:{user_id}" + params: list = [user_id] + where = "" + if cursor: + c_at, c_id = decode_cursor(cursor, scope) + where = "WHERE (c.created_at, c.id) > (%s, %s) " + params += [c_at, c_id] + cur = await conn.execute( + CHAT_SELECT + "JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s " + + where + "ORDER BY c.created_at, c.id LIMIT %s", (*params, limit + 1)) + rows = await cur.fetchall() + page, nxt = _page(rows, limit, scope, key=lambda r: (r[2], r[0])) + return [chat_out(r) for r in page], nxt + + +# ---------------------------------------------------------------- messages +MSG_COLS = "id, chat_id, sender_id, text, created_at" +# lab4: id вложений сообщения в порядке из запроса (пустой массив, если их нет). +MSG_ATTACHMENTS = ( + "COALESCE((SELECT array_agg(ma.attachment_id ORDER BY ma.position) " + "FROM message_attachments ma WHERE ma.message_id = m.id), '{}'::uuid[])") +MSG_SELECT = f"SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at, {MSG_ATTACHMENTS} FROM messages m " + + +def message_out(row) -> dict: + return {"id": str(row[0]), "chat_id": str(row[1]), "sender_id": str(row[2]), + "text": row[3], "created_at": iso(row[4]), + "attachment_ids": [str(x) for x in row[5]]} + + +# ---------------------------------------------------------------- идемпотентность +class IdempotencyConflict(Exception): + """Тот же Idempotency-Key, но другое тело запроса → 409.""" + + +class AttachmentNotFound(Exception): + """Вложения нет или оно из другого чата → 404.""" + + +class AttachmentNotReady(Exception): + """Вложение в состоянии failed → 409 (в lab4 статус всегда ready).""" + + +def request_hash(text: str, attachment_ids: list | None = None) -> bytes: + """Хэш канонического тела: порядок ключей JSON не влияет на результат. + Отсутствующий attachment_ids и [] — одно и то же (контракт), поэтому пустой + список в хэш не входит: ключи, сохранённые lab3 для текстовых сообщений, + после обновления дают тот же хэш.""" + body: dict = {"text": text} + if attachment_ids: + body["attachment_ids"] = [str(x) for x in attachment_ids] + canonical = json.dumps(body, sort_keys=True, ensure_ascii=False, separators=(",", ":")) + return hashlib.sha256(canonical.encode("utf-8")).digest() + + +async def check_attachments(conn, chat_id, attachment_ids: list[uuid.UUID]) -> None: + """Все вложения существуют и принадлежат ЭТОМУ чату; иначе 404 (не раскрываем, + что чужое вложение существует). FOR SHARE: строку нельзя удалить до COMMIT.""" + if not attachment_ids: + return + cur = await conn.execute( + "SELECT id, chat_id, status FROM attachments WHERE id = ANY(%s) FOR SHARE", + (attachment_ids,)) + found = {row[0]: row for row in await cur.fetchall()} + for aid in attachment_ids: + row = found.get(aid) + if row is None or str(row[1]) != str(chat_id): + raise AttachmentNotFound() + if any(row[2] == "failed" for row in found.values()): + raise AttachmentNotReady() + + +async def get_message(conn, message_id) -> dict: + cur = await conn.execute(MSG_SELECT + "WHERE m.id = %s", (message_id,)) + return message_out(await cur.fetchone()) + + +async def send_message_idempotent(conn, chat_id, sender_id, key: str, text: str, + ttl_seconds: int, + attachment_ids: list[uuid.UUID] | None = None) -> dict: + """Записать сообщение ровно один раз для (пользователь, чат, ключ). + Вызывать внутри транзакции: ключ, сообщение и его связи с вложениями + фиксируются вместе или никак, поэтому ошибка (5xx) не оставляет «записанного результата». + + Конкурентные повторы через разные реплики: второй INSERT того же PK ждёт + COMMIT первого (блокировка уникального индекса в PostgreSQL), затем получает + конфликт и читает уже сохранённый результат.""" + attachment_ids = attachment_ids or [] + rhash = request_hash(text, attachment_ids) + msg_id, created = uuid.uuid4(), now() + cur = await conn.execute( + "INSERT INTO idempotency_keys (user_id, chat_id, idem_key, request_hash, message_id, created_at) " + "VALUES (%s, %s, %s, %s, %s, %s) " + "ON CONFLICT (user_id, chat_id, idem_key) DO NOTHING RETURNING 1", + (sender_id, chat_id, key, rhash, msg_id, created)) + if await cur.fetchone() is None: + cur = await conn.execute( + "SELECT request_hash, message_id, created_at < now() - make_interval(secs => %s) " + "FROM idempotency_keys WHERE user_id = %s AND chat_id = %s AND idem_key = %s FOR UPDATE", + (ttl_seconds, sender_id, chat_id, key)) + stored_hash, stored_msg, expired = await cur.fetchone() + if not expired: + if bytes(stored_hash) != rhash: + raise IdempotencyConflict() + return await get_message(conn, stored_msg) # тот же Message, что и в первый раз + # Ключ старше TTL: используем его заново как новый. + await conn.execute( + "UPDATE idempotency_keys SET request_hash = %s, message_id = %s, created_at = %s " + "WHERE user_id = %s AND chat_id = %s AND idem_key = %s", + (rhash, msg_id, created, sender_id, chat_id, key)) + # Вложения проверяются в той же транзакции, что и запись сообщения. + await check_attachments(conn, chat_id, attachment_ids) + await conn.execute( + f"INSERT INTO messages ({MSG_COLS}) VALUES (%s, %s, %s, %s, %s)", + (msg_id, chat_id, sender_id, text, created)) + if attachment_ids: + async with conn.cursor() as c: + await c.executemany( + "INSERT INTO message_attachments (message_id, attachment_id, position) VALUES (%s, %s, %s)", + [(msg_id, aid, pos) for pos, aid in enumerate(attachment_ids)]) + return {"id": str(msg_id), "chat_id": str(chat_id), "sender_id": str(sender_id), + "text": text, "created_at": iso(created), + "attachment_ids": [str(x) for x in attachment_ids]} + + +async def list_messages(conn, chat_id, limit: int, cursor: str | None): + """Keyset-пагинация по индексу (chat_id, created_at, id): без OFFSET и без скана истории.""" + scope = f"messages:{chat_id}" + params: list = [chat_id] + where = "" + if cursor: + c_at, c_id = decode_cursor(cursor, scope) + where = "AND (m.created_at, m.id) > (%s, %s) " + params += [c_at, c_id] + cur = await conn.execute( + MSG_SELECT + "WHERE m.chat_id = %s " + where + + "ORDER BY m.created_at, m.id LIMIT %s", (*params, limit + 1)) + rows = await cur.fetchall() + page, nxt = _page(rows, limit, scope, key=lambda r: (r[4], r[0])) + return [message_out(r) for r in page], nxt + + +# ---------------------------------------------------------------- вложения (lab4) +ATT_COLS = ("id, chat_id, owner_id, filename, content_type, size_bytes, sha256, status, " + "error_code, created_at, updated_at, object_key") + + +def attachment_out(row) -> dict: + """Публичное представление: без object_key, bucket и внутренних адресов.""" + return {"id": str(row[0]), "chat_id": str(row[1]), "owner_id": str(row[2]), + "filename": row[3], "content_type": row[4], "size_bytes": row[5], + "sha256": row[6], "status": row[7], "variants": [], "error_code": row[8], + "created_at": iso(row[9]), "updated_at": iso(row[10])} + + +async def add_upload_intent(conn, object_key: str, attachment_id) -> None: + """Журнал намерения: запись ДО PUT в S3. Если процесс упадёт между PUT и + COMMIT метаданных, по этой строке janitor найдёт и удалит объект-сироту.""" + await conn.execute( + "INSERT INTO upload_intents (object_key, attachment_id, created_at) VALUES (%s, %s, now())", + (object_key, attachment_id)) + + +class IntentLost(Exception): + """Журнал загрузки уже забрал janitor (загрузка шла дольше grace period).""" + + +async def commit_attachment(conn, *, attachment_id, chat_id, owner_id, filename: str, + content_type: str, size_bytes: int, sha256: str, + width: int, height: int, object_key: str) -> dict: + """Вызывать внутри транзакции: метаданные появляются и журнал удаляется атомарно. + Если строки журнала уже нет (её удалил janitor вместе с объектом) — IntentLost.""" + cur = await conn.execute( + "DELETE FROM upload_intents WHERE object_key = %s RETURNING 1", (object_key,)) + if await cur.fetchone() is None: + raise IntentLost() + ts = now() + cur = await conn.execute( + f"INSERT INTO attachments ({ATT_COLS}, width, height) " + "VALUES (%s, %s, %s, %s, %s, %s, %s, 'ready', NULL, %s, %s, %s, %s, %s) " + f"RETURNING {ATT_COLS}", + (attachment_id, chat_id, owner_id, filename, content_type, size_bytes, sha256, + ts, ts, object_key, width, height)) + return attachment_out(await cur.fetchone()) + + +async def drop_upload_intent(conn, object_key: str) -> None: + await conn.execute("DELETE FROM upload_intents WHERE object_key = %s", (object_key,)) + + +async def get_attachment_for_member(conn, attachment_id, user_id): + """Строка вложения, если пользователь состоит в его чате; иначе None (→ 404).""" + cur = await conn.execute( + f"SELECT {ATT_COLS} FROM attachments a WHERE a.id = %s AND EXISTS " + "(SELECT 1 FROM chat_members x WHERE x.chat_id = a.chat_id AND x.user_id = %s)", + (attachment_id, user_id)) + return await cur.fetchone() diff --git a/app/security.py b/app/security.py new file mode 100644 index 00000000..c900880b --- /dev/null +++ b/app/security.py @@ -0,0 +1,46 @@ +""" +Пароли и токены. + +Пароль: Argon2id (password KDF). Он специально медленный и требует память, +поэтому перебор украденных хэшей дорог. Соль своя у каждого хэша. + +Токен сессии: 32 случайных байта (256 бит) из secrets — непрозрачная строка, +не связанная с username/UUID. В БД кладём SHA-256 от токена: для случайного +256-битного значения быстрый хэш достаточен (перебирать нечего), а утечка +таблицы sessions не даёт рабочих токенов. +""" +from __future__ import annotations +import hashlib +import secrets + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError + +_hasher = PasswordHasher() # Argon2id, параметры по умолчанию библиотеки (RFC 9106 low-memory) + +# Хэш-заглушка: проверяем пароль даже для несуществующего пользователя, +# чтобы по времени ответа нельзя было узнать, существует ли username. +_DUMMY_HASH = _hasher.hash("dummy-password-for-timing") + + +def hash_password(password: str) -> str: + return _hasher.hash(password) + + +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 (VerifyMismatchError, VerificationError, InvalidHashError): + return False + + +def needs_rehash(password_hash: str) -> bool: + return _hasher.check_needs_rehash(password_hash) + + +def new_token() -> str: + return secrets.token_urlsafe(32) # 256 бит энтропии + + +def token_hash(token: str) -> bytes: + return hashlib.sha256(token.encode("utf-8")).digest() diff --git a/app/sessions.py b/app/sessions.py new file mode 100644 index 00000000..5f9ced65 --- /dev/null +++ b/app/sessions.py @@ -0,0 +1,168 @@ +""" +Сессии: PostgreSQL — источник истины, Redis/Valkey — кэш поиска сессии. + +Чтение (проверка Bearer): + 1. Ищем в Redis ключ sess:. Нашли и не истёк → пользователь. + 2. Нет в кэше / Redis недоступен → читаем sessions в PostgreSQL + (не отозвана и expires_at > now()) и кладём результат в кэш. + +Политика expiry: срок жизни сессии задаёт PostgreSQL (expires_at). +TTL ключа в Redis = min(SESSION_CACHE_TTL_SECONDS, время до expires_at), +поэтому кэш никогда не продлевает сессию. + +Инвалидация (logout) — атомарно для БД и кэша: + в одной транзакции UPDATE sessions SET revoked_at (строка блокируется), + затем DEL ключа в Redis. Если Redis не ответил — транзакция откатывается и + клиент получает 503: logout НЕ подтверждён, 204 отдаётся только когда + копии отозванной сессии в кэше гарантированно нет. + Гонка «чтение кладёт старую сессию в кэш после DEL» закрыта блокировкой: + чтение из БД идёт с FOR SHARE и кладёт в кэш, не отпуская строку, поэтому + logout ждёт окончания такого чтения и удаляет ключ уже после него. + +Отказ Redis: кэш обходится, всё читается из PostgreSQL (медленнее, но верно). +Flush/рестарт Redis: кэш пустой → сессии восстанавливаются из PostgreSQL. +Отказ PostgreSQL: новые проверки идут в БД → 503, анонимный запрос не принимается. +""" +from __future__ import annotations +import json +import logging +from datetime import datetime, timedelta, timezone + +import redis.asyncio as aioredis +from redis.exceptions import RedisError + +from .config import settings +from .security import new_token, token_hash + +log = logging.getLogger("messenger.sessions") + +_redis: aioredis.Redis | None = None + + +def init_redis() -> None: + global _redis + if settings.redis_url: + _redis = aioredis.Redis.from_url( + settings.redis_url, + socket_timeout=settings.redis_timeout, + socket_connect_timeout=settings.redis_timeout, + decode_responses=True, + ) + + +async def close_redis() -> None: + if _redis is not None: + await _redis.aclose() + + +def redis_enabled() -> bool: + return _redis is not None + + +async def redis_ping() -> bool: + if _redis is None: + return False + try: + return bool(await _redis.ping()) + except (RedisError, OSError): + return False + + +def _key(th: bytes) -> str: + return "sess:" + th.hex() + + +async def _cache_get(th: bytes) -> dict | None: + if _redis is None: + return None + try: + raw = await _redis.get(_key(th)) + except (RedisError, OSError) as exc: + log.warning("redis unavailable on read, bypassing cache: %s", type(exc).__name__) + return None + return json.loads(raw) if raw else None + + +async def _cache_put(th: bytes, user: dict, expires_at: datetime) -> None: + if _redis is None: + return + left = int((expires_at - datetime.now(timezone.utc)).total_seconds()) + ttl = min(settings.session_cache_ttl_seconds, left) + if ttl <= 0: + return + try: + await _redis.set(_key(th), json.dumps({"user": user, "exp": expires_at.isoformat()}), ex=ttl) + except (RedisError, OSError) as exc: + log.warning("redis unavailable on write, skipping cache: %s", type(exc).__name__) + + +class CacheUnavailable(Exception): + """Redis не подтвердил удаление ключа — отзыв сессии нельзя гарантировать.""" + + +async def _cache_delete_strict(th: bytes) -> None: + """Удалить копию сессии из кэша или поднять CacheUnavailable. + Молча проглатывать ошибку нельзя: если Redis «приостановлен», ключ + переживёт сбой и после восстановления отозванный токен снова примут.""" + if _redis is None: + return + try: + await _redis.delete(_key(th)) + except (RedisError, OSError) as exc: + log.warning("redis unavailable on invalidate: %s", type(exc).__name__) + raise CacheUnavailable() from exc + + +async def create_session(conn, user_id) -> tuple[str, datetime]: + token = new_token() + now = datetime.now(timezone.utc) + expires_at = now + timedelta(seconds=settings.session_ttl_seconds) + await conn.execute( + "INSERT INTO sessions (token_hash, user_id, created_at, expires_at) " + "VALUES (%s, %s, %s, %s)", + (token_hash(token), user_id, now, expires_at)) + return token, expires_at + + +async def resolve(pool, token: str, load_user) -> dict | None: + """Вернёт пользователя (dict) для действующего токена или None.""" + th = token_hash(token) + cached = await _cache_get(th) + if cached is not None: + if datetime.fromisoformat(cached["exp"]) > datetime.now(timezone.utc): + return cached["user"] + return None + async with pool.connection() as conn: + # FOR SHARE: пока эта транзакция не закончилась (вместе с записью в кэш), + # logout не сможет отозвать строку — он дождётся и удалит ключ после нас. + cur = await conn.execute( + "SELECT user_id, expires_at FROM sessions " + "WHERE token_hash = %s AND revoked_at IS NULL AND expires_at > now() " + "FOR SHARE", + (th,)) + row = await cur.fetchone() + if row is None: + return None + user = await load_user(conn, row[0]) + if user is None: + return None + await _cache_put(th, user, row[1]) + return user + + +async def revoke(pool, token: str) -> bool: + """Отозвать сессию. True — была действующая и теперь отозвана (и в БД, и в кэше). + False — сессии нет/уже отозвана. CacheUnavailable — Redis не ответил: + транзакция откатана, сессия осталась действующей, logout не подтверждён.""" + th = token_hash(token) + async with pool.connection() as conn: + async with conn.transaction(): + cur = await conn.execute( + "UPDATE sessions SET revoked_at = now() " + "WHERE token_hash = %s AND revoked_at IS NULL AND expires_at > now() " + "RETURNING 1", (th,)) + if await cur.fetchone() is None: + return False + # Внутри транзакции: ошибка Redis → исключение → ROLLBACK отзыва. + await _cache_delete_strict(th) + return True diff --git a/app/storage.py b/app/storage.py new file mode 100644 index 00000000..006c83ac --- /dev/null +++ b/app/storage.py @@ -0,0 +1,211 @@ +""" +Объектное хранилище (S3-совместимое, MinIO) — только БАЙТЫ вложений. + +- Метаданные (кто, какой чат, sha256, размер, тип) — в PostgreSQL, источник истины. +- Ключ объекта назначает сервер: originals/. Имя файла от клиента + в ключ не попадает (нет path traversal и подбора чужих ключей по имени). +- Bucket приватный, API ходит отдельными credentials с правами только на + этот bucket (см. infra/minio/). Root MinIO у API нет. +- boto3 синхронный → все вызовы идут в пуле потоков (не блокируют event loop). +- Таймауты и ограниченные повторы: недоступный S3 даёт 503, а не зависание. +""" +from __future__ import annotations + +import logging +import time +from datetime import datetime +from typing import BinaryIO, Iterator + +import boto3 +from botocore.config import Config +from botocore.exceptions import (BotoCoreError, ClientError, ConnectionClosedError, + ConnectTimeoutError, EndpointConnectionError) +from fastapi.concurrency import run_in_threadpool + +from .config import settings + +log = logging.getLogger("messenger.storage") + +ORIGINALS_PREFIX = "originals/" +_client = None + +# Предохранитель (circuit breaker) реплики: если S3 не отвечает на уровне соединения +# (контейнер остановлен, имя не резолвится), следующие S3_BREAKER_SECONDS секунд +# запросы к S3 сразу получают 503, не тратя время на DNS/connect и повторы. +_CONNECTION_ERRORS = (EndpointConnectionError, ConnectTimeoutError, ConnectionClosedError) +_down_until = 0.0 + + +class StorageUnavailable(Exception): + """S3 недоступен/не ответил/отказал → 503.""" + + +class ObjectMissing(Exception): + """Объекта нет (NoSuchKey).""" + + +def object_key(attachment_id) -> str: + return f"{ORIGINALS_PREFIX}{attachment_id}" + + +def make_client(): + return boto3.client( + "s3", + endpoint_url=settings.s3_endpoint, + region_name=settings.s3_region, + aws_access_key_id=settings.s3_access_key_id or None, + aws_secret_access_key=settings.s3_secret_access_key or None, + config=Config( + signature_version="s3v4", + s3={"addressing_style": "path"}, # MinIO: http://s3:9000// + connect_timeout=settings.s3_connect_timeout, + read_timeout=settings.s3_read_timeout, + retries={"max_attempts": settings.s3_max_attempts, "mode": "standard"}, + max_pool_connections=max(10, settings.upload_max_concurrent), + # Контрольную сумму передаём сами (Content-MD5); не включаем + # aws-chunked/CRC по умолчанию новых botocore — совместимость с MinIO. + request_checksum_calculation="when_required", + response_checksum_validation="when_required", + ), + ) + + +def init() -> None: + global _client + _client = make_client() + + +def client(): + if _client is None: + init() + return _client + + +def _why(exc: Exception) -> str: + """Тип и код ошибки S3 для лога (без ключей, подписей и адресов).""" + if isinstance(exc, ClientError): + return f"{type(exc).__name__}:{exc.response.get('Error', {}).get('Code', '?')}" + return type(exc).__name__ + + +def _guard() -> None: + if time.monotonic() < _down_until: + raise StorageUnavailable("circuit open") + + +def ensure_available() -> None: + """Быстрый отказ ДО записи журнала загрузки, пока предохранитель открыт.""" + _guard() + + +def _trip(exc: Exception) -> None: + global _down_until + if isinstance(exc, _CONNECTION_ERRORS): + _down_until = time.monotonic() + settings.s3_breaker_seconds + + +def _is_missing(exc: ClientError) -> bool: + code = exc.response.get("Error", {}).get("Code", "") + return code in ("NoSuchKey", "404", "NotFound") + + +# ----------------------------------------------------------- синхронные вызовы +def put_sync(key: str, body: BinaryIO, size: int, content_type: str, + md5_b64: str, sha256_hex: str) -> None: + _guard() + body.seek(0) + try: + client().put_object( + Bucket=settings.s3_bucket, Key=key, Body=body, ContentLength=size, + ContentType=content_type, + ContentMD5=md5_b64, # S3 сверит и отклонит повреждённую передачу + Metadata={"sha256": sha256_hex}, + ) + except (BotoCoreError, ClientError) as exc: + _trip(exc) + log.warning("s3 put failed: %s", _why(exc)) + raise StorageUnavailable() from exc + + +def open_sync(key: str): + """(поток байтов, длина). Поток читается кусками — файл не грузится в RAM целиком.""" + _guard() + try: + obj = client().get_object(Bucket=settings.s3_bucket, Key=key) + except ClientError as exc: + if _is_missing(exc): + raise ObjectMissing() from exc + log.warning("s3 get failed: %s", _why(exc)) + raise StorageUnavailable() from exc + except BotoCoreError as exc: + _trip(exc) + log.warning("s3 get failed: %s", _why(exc)) + raise StorageUnavailable() from exc + return obj["Body"], obj["ContentLength"] + + +def iter_body(body, chunk_size: int = 64 * 1024) -> Iterator[bytes]: + try: + yield from body.iter_chunks(chunk_size) + finally: + body.close() + + +def delete_sync(key: str) -> None: + """Идемпотентно: удаление отсутствующего объекта в S3 — тоже успех.""" + _guard() + try: + client().delete_object(Bucket=settings.s3_bucket, Key=key) + except (BotoCoreError, ClientError) as exc: + _trip(exc) + log.warning("s3 delete failed: %s", _why(exc)) + raise StorageUnavailable() from exc + + +def exists_sync(key: str) -> bool: + try: + client().head_object(Bucket=settings.s3_bucket, Key=key) + return True + except ClientError as exc: + if _is_missing(exc): + return False + raise StorageUnavailable() from exc + except BotoCoreError as exc: + raise StorageUnavailable() from exc + + +def list_sync(prefix: str = ORIGINALS_PREFIX) -> Iterator[tuple[str, datetime, int]]: + """(key, LastModified, Size) всех объектов под prefix — постранично, без загрузки всего списка.""" + try: + pages = client().get_paginator("list_objects_v2").paginate( + Bucket=settings.s3_bucket, Prefix=prefix, PaginationConfig={"PageSize": 1000}) + for page in pages: + for obj in page.get("Contents", []): + yield obj["Key"], obj["LastModified"], obj["Size"] + except (BotoCoreError, ClientError) as exc: + raise StorageUnavailable() from exc + + +def ping_sync() -> bool: + try: + client().head_bucket(Bucket=settings.s3_bucket) + return True + except (BotoCoreError, ClientError): + return False + + +# ----------------------------------------------------------- async-обёртки +async def put(key, body, size, content_type, md5_b64, sha256_hex) -> None: + await run_in_threadpool(put_sync, key, body, size, content_type, md5_b64, sha256_hex) + + +async def open_object(key: str): + return await run_in_threadpool(open_sync, key) + + +async def delete(key: str) -> None: + await run_in_threadpool(delete_sync, key) + + +async def ping() -> bool: + return await run_in_threadpool(ping_sync) diff --git a/app/tools.py b/app/tools.py new file mode 100644 index 00000000..54dc5521 --- /dev/null +++ b/app/tools.py @@ -0,0 +1,167 @@ +""" +Служебные проверки хранилища для тестов и защиты (не HTTP API). +Запуск внутри контейнера api (он в сети storage): + + python -m app.tools private-check # bucket приватный, права API ограничены + python -m app.tools stats # число объектов / attachments / upload_intents + python -m app.tools state # есть ли объект, метаданные, журнал + python -m app.tools find-local # нет ли на диске реплики копии файла + +Секреты не печатаются. Ключи объектов печатаются только для служебного prefix. +""" +from __future__ import annotations + +import json +import sys +import urllib.error +import urllib.request +import uuid + +import psycopg +from botocore.exceptions import ClientError + +from . import storage +from .config import settings + + +def _anon(method: str, path: str, data: bytes | None = None) -> int: + """HTTP-запрос к MinIO БЕЗ подписи (как посторонний клиент).""" + req = urllib.request.Request(settings.s3_endpoint.rstrip("/") + path, data=data, method=method) + try: + with urllib.request.urlopen(req, timeout=5) as r: + return r.status + except urllib.error.HTTPError as e: + return e.code + + +def _denied(fn) -> str: + try: + fn() + return "ALLOWED" + except ClientError as exc: + return exc.response.get("Error", {}).get("Code", "error") + + +def private_check() -> int: + s3 = storage.client() + bucket = settings.s3_bucket + probe = f"{storage.ORIGINALS_PREFIX}privacy-probe-{uuid.uuid4()}" + results: list[tuple[str, str, bool]] = [] + + def check(name: str, observed, ok: bool) -> None: + results.append((name, str(observed), ok)) + + s3.put_object(Bucket=bucket, Key=probe, Body=b"probe", ContentType="text/plain") + try: + # Позитивный контроль: объект существует и API-пользователь его читает. + body = s3.get_object(Bucket=bucket, Key=probe)["Body"].read() + check("API credentials: GET own object", "200", body == b"probe") + # Аноним: ни чтения, ни листинга, ни записи. + st = _anon("GET", f"/{bucket}/{probe}") + check("anonymous GET object", st, st == 403) + st = _anon("GET", f"/{bucket}?list-type=2") + check("anonymous LIST bucket", st, st == 403) + st = _anon("PUT", f"/{bucket}/{storage.ORIGINALS_PREFIX}anon-{uuid.uuid4()}", b"x") + check("anonymous PUT object", st, st == 403) + # Ограниченные права API-пользователя: только объекты своего bucket. + # MinIO без s3:ListAllMyBuckets либо отказывает, либо показывает только + # бакеты, на которые есть права, — чужие бакеты API-пользователь не видит. + try: + names = sorted(b["Name"] for b in s3.list_buckets().get("Buckets", [])) + r = "only " + ",".join(names) if names else "empty" + ok = set(names) <= {bucket} + except ClientError as exc: + r = exc.response.get("Error", {}).get("Code", "error") + ok = r == "AccessDenied" + check("API credentials: ListBuckets (no foreign buckets)", r, ok) + r = _denied(lambda: s3.create_bucket(Bucket="lab4-forbidden-" + uuid.uuid4().hex[:8])) + check("API credentials: CreateBucket", r, r == "AccessDenied") + public = json.dumps({"Version": "2012-10-17", "Statement": [{ + "Effect": "Allow", "Principal": {"AWS": ["*"]}, "Action": ["s3:GetObject"], + "Resource": [f"arn:aws:s3:::{bucket}/*"]}]}) + r = _denied(lambda: s3.put_bucket_policy(Bucket=bucket, Policy=public)) + check("API credentials: PutBucketPolicy (make public)", r, r == "AccessDenied") + r = _denied(lambda: s3.delete_bucket(Bucket=bucket)) + check("API credentials: DeleteBucket", r, r == "AccessDenied") + finally: + s3.delete_object(Bucket=bucket, Key=probe) + + width = max(len(n) for n, _, _ in results) + for name, observed, ok in results: + print(f" {'ok ' if ok else 'FAIL'} {name.ljust(width)} -> {observed}") + failed = sum(1 for _, _, ok in results if not ok) + print(f"\n{len(results) - failed} passed, {failed} failed") + return 1 if failed else 0 + + +def _db(): + return psycopg.connect(settings.database_url, connect_timeout=3) + + +def stats() -> int: + objects = sum(1 for _ in storage.list_sync()) + with _db() as conn: + attachments = conn.execute("SELECT count(*) FROM attachments").fetchone()[0] + intents = conn.execute("SELECT count(*) FROM upload_intents").fetchone()[0] + print(json.dumps({"objects": objects, "attachments": attachments, "upload_intents": intents})) + return 0 + + +def state(attachment_id: str) -> int: + key = storage.object_key(uuid.UUID(attachment_id)) + with _db() as conn: + att = conn.execute("SELECT 1 FROM attachments WHERE object_key = %s", (key,)).fetchone() + intent = conn.execute("SELECT 1 FROM upload_intents WHERE object_key = %s", (key,)).fetchone() + print(json.dumps({"object_exists": storage.exists_sync(key), + "attachment_row": att is not None, "upload_intent": intent is not None})) + return 0 + + +def find_local(digest: str) -> int: + """Обойти файловую систему контейнера API и найти файлы с таким SHA-256. + Доказательство, что оригинал не хранится на реплике (только в S3).""" + import hashlib + import os + skip = ("/proc", "/sys", "/dev", "/usr", "/lib", "/bin", "/sbin", "/etc", "/var/lib/dpkg") + scanned, found = 0, [] + for root, dirs, files in os.walk("/"): + if root.startswith(skip): + dirs[:] = [] + continue + for name in files: + path = os.path.join(root, name) + try: + if not os.path.isfile(path) or os.path.getsize(path) > 32 * 1024 * 1024: + continue + h = hashlib.sha256() + with open(path, "rb") as f: + for block in iter(lambda: f.read(1 << 20), b""): + h.update(block) + scanned += 1 + if h.hexdigest() == digest: + found.append(path) + except OSError: + continue + print(json.dumps({"files_scanned": scanned, "copies_found": found})) + return 1 if found else 0 + + +def main(argv: list[str]) -> int: + if not argv: + print(__doc__) + return 2 + cmd, args = argv[0], argv[1:] + if cmd == "private-check": + return private_check() + if cmd == "stats": + return stats() + if cmd == "state" and len(args) == 1: + return state(args[0]) + if cmd == "find-local" and len(args) == 1: + return find_local(args[0]) + print(__doc__) + return 2 + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/app/uploads.py b/app/uploads.py new file mode 100644 index 00000000..e83f2669 --- /dev/null +++ b/app/uploads.py @@ -0,0 +1,106 @@ +""" +Приём тела загрузки (lab4): потоково, с лимитами, без накопления файла в RAM. + +- Content-Length больше лимита → 413 сразу, тело не читается. +- Тело читается кусками (как пришли из сокета) и одновременно: + считается SHA-256 и MD5, растёт счётчик байт. Как только байт больше лимита — + 413, чтение прекращается (работает и для chunked без Content-Length). +- Байты копятся в SpooledTemporaryFile: первые UPLOAD_SPOOL_MEMORY_BYTES в памяти, + дальше — во временном файле. Это буфер одного запроса, а не хранилище: + файл удаляется при закрытии (в finally), оригинал живёт только в S3. +- Общий таймаут на всё тело: «медленный» клиент не держит слот вечно. +""" +from __future__ import annotations + +import asyncio +import base64 +import hashlib +import tempfile +import unicodedata +from dataclasses import dataclass +from typing import BinaryIO + +from starlette.requests import ClientDisconnect, Request + +ALLOWED_TYPES = ("image/png", "image/jpeg") +# Управляющие символы направления текста: «photo‮gnp.exe» выглядит как «photoexe.png». +_BIDI_CONTROLS = set("‎‏‪‫‬‭‮⁦⁧⁨⁩") + + +class UploadError(Exception): + def __init__(self, status: int, code: str, message: str): + self.status, self.code, self.message = status, code, message + + +def validate_filename(name: str | None) -> str: + """filename — только отображаемое имя. Отклоняем всё, что похоже на путь + или прячет настоящий вид имени. Никаких «исправлений»: либо как есть, либо 400.""" + if name is None or not (1 <= len(name) <= 255) or not name.strip(): + raise UploadError(400, "invalid_request", "filename must be 1..255 characters") + if name in (".", ".."): + raise UploadError(400, "invalid_request", "filename is not allowed") + for ch in name: + if ch in "/\\" or ch == "\x00" or ch in _BIDI_CONTROLS \ + or unicodedata.category(ch) in ("Cc", "Cs"): + raise UploadError(400, "invalid_request", "filename contains forbidden characters") + return name + + +def declared_type(request: Request) -> str: + media = request.headers.get("content-type", "").split(";", 1)[0].strip().lower() + if media not in ALLOWED_TYPES: + raise UploadError(415, "unsupported_media_type", "Content-Type must be image/png or image/jpeg") + return media + + +def check_declared_length(request: Request, limit: int) -> int | None: + raw = request.headers.get("content-length") + if raw is None: + return None + if not raw.isdigit(): + raise UploadError(400, "invalid_request", "bad Content-Length") + length = int(raw) + if length > limit: + # Отказ до чтения тела: ни байта сверх заголовков не принимаем. + raise UploadError(413, "payload_too_large", f"file is larger than {limit} bytes") + return length + + +@dataclass +class Received: + file: BinaryIO + size: int + sha256_hex: str + md5_b64: str + + +async def receive(request: Request, limit: int, timeout: float, spool_memory: int) -> Received: + spool = tempfile.SpooledTemporaryFile(max_size=spool_memory, prefix="upload-") + sha, md5 = hashlib.sha256(), hashlib.md5(usedforsecurity=False) + size = 0 + try: + async with asyncio.timeout(timeout): + async for chunk in request.stream(): + if not chunk: + continue + size += len(chunk) + if size > limit: + raise UploadError(413, "payload_too_large", f"file is larger than {limit} bytes") + sha.update(chunk) + md5.update(chunk) + spool.write(chunk) + except TimeoutError: + spool.close() + raise UploadError(400, "invalid_request", "request body was not received in time") from None + except ClientDisconnect: + # Прерванная загрузка: в S3 ничего не записано, буфер удаляется здесь. + spool.close() + raise UploadError(400, "invalid_request", "upload was interrupted") from None + except BaseException: + spool.close() + raise + if size == 0: + spool.close() + raise UploadError(400, "invalid_request", "request body is empty") + spool.seek(0) + return Received(spool, size, sha.hexdigest(), base64.b64encode(md5.digest()).decode()) diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..da92bc96 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,251 @@ +# Стенд lab4: клиент → lb (HAProxy) → api × 2 → PostgreSQL (метаданные) + Redis (кэш сессий) +# └→ MinIO, приватный bucket (байты вложений) +# Запуск: docker compose --env-file .env up -d --build +# Публичный только lb (127.0.0.1:8080). Реплики API и MinIO наружу не публикуются. +# +# Сети: +# app — lb, api, postgres, redis (как в lab3); +# storage — internal: только s3, s3-init и api. Ни lb, ни хост туда не попадают: +# API и админ-API MinIO (порт 9000) доступны лишь внутри этой сети, +# веб-консоль MinIO выключена (MINIO_BROWSER=off). +name: mtusi-lab4 + +x-api-env: &api-env + DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB} + CACHE_URL: redis://redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60} + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + DB_POOL_MAX: ${DB_POOL_MAX:-10} + DB_POOL_TIMEOUT: ${DB_POOL_TIMEOUT:-3} + DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000} + REDIS_TIMEOUT: ${REDIS_TIMEOUT:-0.5} + SHUTDOWN_TIMEOUT: ${SHUTDOWN_TIMEOUT:-10} + LOG_LEVEL: ${LOG_LEVEL:-info} + # Миграции выполняет отдельный сервис migrate, а не каждая реплика. + MIGRATE_ON_START: "false" + # lab4: S3. У API — ОТДЕЛЬНЫЙ пользователь MinIO с правами только на свой bucket. + # Root-credentials MinIO в API не передаются. + S3_ENDPOINT: http://s3:9000 + S3_REGION: ${S3_REGION:-us-east-1} + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID} + S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY} + S3_CONNECT_TIMEOUT: ${S3_CONNECT_TIMEOUT:-2} + S3_READ_TIMEOUT: ${S3_READ_TIMEOUT:-10} + MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760} + MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000} + UPLOAD_BODY_TIMEOUT_SECONDS: ${UPLOAD_BODY_TIMEOUT_SECONDS:-60} + UPLOAD_SPOOL_MEMORY_BYTES: ${UPLOAD_SPOOL_MEMORY_BYTES:-262144} + UPLOAD_MAX_CONCURRENT: ${UPLOAD_MAX_CONCURRENT:-16} + IMAGE_CHECK_CONCURRENCY: ${IMAGE_CHECK_CONCURRENCY:-2} + UPLOAD_GRACE_SECONDS: ${UPLOAD_GRACE_SECONDS:-900} + JANITOR_INTERVAL_SECONDS: ${JANITOR_INTERVAL_SECONDS:-60} + S3_BREAKER_SECONDS: ${S3_BREAKER_SECONDS:-5} + PASSWORD_HASH_CONCURRENCY: ${PASSWORD_HASH_CONCURRENCY:-2} + +# Сеть storage — internal: если s3 остановлен, его имя не резолвится, и встроенный DNS +# Docker пытается спросить внешний DNS, которого из internal-сети нет → по 5+ c на запрос. +# Короткий таймаут резолвера: недоступный S3 даёт быстрый 503, а не «зависание». +x-dns-opt: &dns-opt ["timeout:1", "attempts:1"] + +services: + postgres: + image: postgres:16.4-alpine + environment: + POSTGRES_DB: ${POSTGRES_DB} + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + volumes: + - pgdata:/var/lib/postgresql/data + networks: [app] + healthcheck: + test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"] + interval: 5s + timeout: 3s + retries: 20 + deploy: + resources: + limits: {cpus: "1.0", memory: 512M} + restart: unless-stopped + + redis: + image: redis:7.4.1-alpine + # Только кэш сессий: источник истины — PostgreSQL, persistence не нужен. + command: ["redis-server", "--save", "", "--appendonly", "no", + "--maxmemory", "64mb", "--maxmemory-policy", "allkeys-lru"] + networks: [app] + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 20 + deploy: + resources: + limits: {cpus: "0.25", memory: 96M} + restart: unless-stopped + + # lab4: S3-совместимое хранилище. Версия закреплена; данные — в volume s3data. + # Официальные образы MinIO больше не скачиваются анонимно (Docker Hub — удалены, + # quay.io — 401). Используем сборку MinIO от сообщества Pigsty (тот же код MinIO, + # тот же CLI/env), версия закреплена. + s3: + image: pgsty/minio:RELEASE.2026-08-04T00-00-00Z + command: ["server", "/data"] + environment: + MINIO_ROOT_USER: ${MINIO_ROOT_USER} + MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD} + MINIO_BROWSER: "off" # веб-консоль выключена совсем + volumes: + - s3data:/data + networks: [storage] # портов наружу нет + healthcheck: + test: ["CMD", "mc", "ready", "local"] + interval: 5s + timeout: 5s + retries: 20 + deploy: + resources: + limits: {cpus: "1.0", memory: 512M} + restart: unless-stopped + + # Однократный идемпотентный bootstrap: bucket (private), политика, пользователь API. + # Повторный запуск ничего не ломает (mb --ignore-existing, policy/user перезаписываются). + s3-init: + image: pgsty/mc:RELEASE.2026-09-16T00-00-00Z # клиент MinIO (mc) той же сборки + entrypoint: ["/bin/sh", "/infra/bootstrap.sh"] + environment: + MINIO_ROOT_USER: ${MINIO_ROOT_USER} + MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD} + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID} + S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY} + volumes: + - ./infra/minio:/infra:ro + networks: [storage] + depends_on: + s3: + condition: service_healthy + deploy: + resources: + limits: {cpus: "0.25", memory: 128M} + restart: "no" + + # Однократные миграции до старта реплик (advisory lock защищает и от повтора). + migrate: + build: . + image: mtusi-messenger:lab4 + command: ["python", "-m", "app.migrate"] + environment: *api-env + networks: [app] + depends_on: + postgres: + condition: service_healthy + deploy: + resources: + limits: {cpus: "0.5", memory: 256M} + restart: "no" + + api: + build: . + image: mtusi-messenger:lab4 + environment: *api-env + dns_opt: *dns-opt + # Портов наружу нет: доступ только через lb. container_name не задан — сервис масштабируется. + expose: ["8080"] + networks: [app, storage] + deploy: + replicas: ${API_REPLICAS:-2} + resources: + limits: {cpus: "0.5", memory: 256M} + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=2).status==200 else 1)"] + interval: 5s + timeout: 3s + retries: 3 + start_period: 5s + # docker stop → SIGTERM: uvicorn перестаёт принимать соединения и дожидается текущих запросов. + stop_grace_period: 15s + depends_on: + migrate: + condition: service_completed_successfully + s3-init: + condition: service_completed_successfully + postgres: + condition: service_healthy + redis: + condition: service_started + restart: unless-stopped + + lb: + image: haproxy:3.0.5-alpine + volumes: + - ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + ports: + - "127.0.0.1:8080:8080" + - "127.0.0.1:8081:8081" + - "127.0.0.1:8082:8082" + networks: [app] + healthcheck: + test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8404/healthz"] + interval: 5s + timeout: 3s + retries: 3 + deploy: + resources: + limits: {cpus: "0.5", memory: 128M} + depends_on: + api: + condition: service_started + restart: unless-stopped + + # API с коротким сроком сессии — только для теста истечения (профиль ttl). + # Доступен тоже только через lb: http://localhost:8081 + api-ttl: + image: mtusi-messenger:lab4 + pull_policy: never # образ собирается локально сервисом api + environment: + <<: *api-env + SESSION_TTL_SECONDS: "2" + JANITOR_ENABLED: "false" + dns_opt: *dns-opt + expose: ["8080"] + networks: [app, storage] + deploy: + resources: + limits: {cpus: "0.25", memory: 192M} + depends_on: + postgres: + condition: service_healthy + profiles: ["ttl"] + + # Реплика с внедрением отказов (профиль fault) — только для student-tests/orphans.py. + # Заголовок X-Fault-Inject работает ТОЛЬКО здесь (FAULT_INJECTION=true). + # Доступна только через lb: http://localhost:8082 + api-fault: + image: mtusi-messenger:lab4 + pull_policy: never + environment: + <<: *api-env + FAULT_INJECTION: "true" + JANITOR_ENABLED: "false" + dns_opt: *dns-opt + expose: ["8080"] + networks: [app, storage] + deploy: + resources: + limits: {cpus: "0.5", memory: 256M} + depends_on: + postgres: + condition: service_healthy + restart: unless-stopped # после crash-after-s3-put контейнер поднимется сам + profiles: ["fault"] + +networks: + app: {} + storage: + internal: true # без выхода наружу и без публикации портов + +volumes: + pgdata: + s3data: diff --git a/evidence/attachments.txt b/evidence/attachments.txt new file mode 100644 index 00000000..9f251c86 --- /dev/null +++ b/evidence/attachments.txt @@ -0,0 +1,107 @@ +# attachments +# date: 2026-10-29T19:34:36 commit: no-git + +$ C:\Users\79152\AppData\Local\Python\pythoncore-3.14-64\python.exe student-tests/attachments.py --base-url http://localhost:8080 +== позитивный сценарий == + ok - upload PNG -> 201 (got 201) + ok - 201 ready, variants=[], error_code=null + ok - sha256/size describe the original + ok - no S3 key/bucket in public JSON + ok - upload JPEG with Unicode filename -> 201 (got 201) + ok - filename returned as is (display only) + ok - member downloads PNG -> 200 (got 200) + ok - downloaded bytes are identical (sha256) + ok - true Content-Type image/png + ok - nosniff header + ok - member downloads JPEG (variant=original) -> 200 (got 200) + ok - JPEG bytes and type + ok - message with empty text + 2 attachments -> 201 (got 201) + ok - attachment_ids kept in request order + ok - history shows attachment_ids + ok - text-only POST (lab3) still valid, attachment_ids=[] + ok - member reads metadata -> 200 (got 200) + ok - thumbnail variant does not exist in lab4 -> 404 (got 404) + ok - unknown variant name -> 400 (got 400) +== доступ == + ok - outsider GET attachment metadata -> 404 (got 404) + ok - unknown attachment metadata -> 404 (got 404) + ok - outsider GET attachment/content -> 404 (got 404) + ok - unknown attachment/content -> 404 (got 404) + ok - anonymous download -> 401 (got 401) + ok - attachment id is not a UUID -> 400 (got 400) + ok - outsider uploads into foreign chat -> 404 (got 404) + ok - anonymous upload -> 401 (got 401) +== привязка к сообщению == + ok - eve uploads into her own chat -> 201 (got 201) + ok - alice uploads into her second chat -> 201 (got 201) + ok - foreign attachment_id (eve's chat) in message -> 404 (got 404) + ok - attachment of ANOTHER chat of the same user -> 404 (got 404) + ok - unknown attachment_id -> 404 (got 404) + ok - one valid + one foreign -> whole message rejected -> 404 (got 404) + ok - duplicate attachment_ids -> 400 (got 400) + ok - same UUID in different case is a duplicate -> 400 (got 400) + ok - more than 10 attachment_ids -> 400 (got 400) + ok - attachment_id is not a UUID -> 400 (got 400) + ok - attachment_ids: null -> 400 (got 400) + ok - blank text without attachments -> 400 (got 400) + ok - text field is required -> 400 (got 400) + ok - any member may reference a chat attachment again -> 201 (got 201) + ok - eve attaches alice's file to her own chat -> 404 (got 404) +== идемпотентность с вложениями == + ok - missing attachment_ids == [] (same Message) + ok - same key, different attachment_ids -> 409 (got 409) + ok - replay with attachments returns the same Message +== размер == + ok - Content-Length = 10 MiB + 1, body never sent (limit before reading) -> 413 (got 413) + ok - Content-Length = 500 MiB -> 413 (got 413) + ok - chunked body > 10 MiB without Content-Length (stream cut at limit) -> 413 (got 413) + ok - real PNG of 11424141 bytes -> 413 (got 413) + ok - empty body -> 400 (got 400) +== пиксели == + ok - decompression bomb 8000x8000 in 62290 bytes -> 413 (got 413) + ok - 40 040 001 pixels (just over the limit) -> 413 (got 413) +== повреждённые файлы == + ok - truncated PNG -> 415 (got 415) + ok - truncated PNG: error code + ok - PNG with flipped byte (CRC) -> 415 (got 415) + ok - PNG with flipped byte (CRC): error code + ok - PNG signature only -> 415 (got 415) + ok - PNG signature only: error code + ok - PNG header + garbage -> 415 (got 415) + ok - PNG header + garbage: error code + ok - truncated JPEG -> 415 (got 415) + ok - truncated JPEG: error code + ok - JPEG SOI + garbage -> 415 (got 415) + ok - JPEG SOI + garbage: error code +== fuzz: случайные порчи байтов (только 201 или 415, никогда 500) == + ok - 30 corrupted files -> only 201/415 (got [201, 415]) +== подмена MIME == + ok - PNG bytes sent as image/jpeg -> 415 (got 415) + ok - JPEG bytes sent as image/png -> 415 (got 415) + ok - text renamed to .png -> 415 (got 415) + ok - GIF sent as image/png -> 415 (got 415) + ok - HTML sent as image/jpeg -> 415 (got 415) + ok - PNG with Content-Type image/gif -> 415 (got 415) + ok - PNG with Content-Type application/octet-stream -> 415 (got 415) + ok - PNG with Content-Type text/html -> 415 (got 415) +== опасные filename == + ok - filename '../../etc/passwd' -> 400 (got 400) + ok - filename 'dir/a.png' -> 400 (got 400) + ok - filename 'C:\\Windows\\a.png' -> 400 (got 400) + ok - filename 'a\x00.png' -> 400 (got 400) + ok - filename 'a\nb.png' -> 400 (got 400) + ok - filename 'tab\t.png' -> 400 (got 400) + ok - filename '\x1b[31mred.png' -> 400 (got 400) + ok - filename 'photo\u202egnp.exe' -> 400 (got 400) + ok - filename '..' -> 400 (got 400) + ok - filename '.' -> 400 (got 400) + ok - filename ' ' -> 400 (got 400) + ok - filename 'xxxxxxxxxxxxxxxxxxxx' -> 400 (got 400) + ok - filename missing -> 400 (got 400) + ok - filename of exactly 255 chars -> 201 (got 201) + ok - filename with spaces, Unicode and punctuation -> 201 (got 201) + ok - media type parameters are ignored -> 201 (got 201) + ok - no 500 and no dropped connection among 99 checked responses + +90 passed, 0 failed +[exit 0] diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 00000000..7acdbb0d --- /dev/null +++ b/evidence/check.txt @@ -0,0 +1,6 @@ +# check +# date: 2026-10-29T19:34:08 commit: no-git + +$ C:\Users\79152\AppData\Local\Python\pythoncore-3.14-64\python.exe scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +[exit 0] diff --git a/evidence/failover.txt b/evidence/failover.txt new file mode 100644 index 00000000..166cbd11 --- /dev/null +++ b/evidence/failover.txt @@ -0,0 +1,52 @@ +# failover +# date: 2026-10-29T19:39:32 commit: no-git + +$ C:\Users\79152\AppData\Local\Python\pythoncore-3.14-64\python.exe tests/resilience.py --mode failover --action-script C:\Users\79152\Downloads\mtusi2026lab4-solution (1)\mtusi2026lab4\scripts\stop-one.cmd --base-url http://localhost:8080 +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 113, "failed_attempts": 0, "first_recovery_seconds": 2.028} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +[exit 0] + +$ C:\Users\79152\Downloads\mtusi2026lab4-solution (1)\mtusi2026lab4\scripts\restore-api.cmd + Container mtusi-lab4-postgres-1 Waiting + Container mtusi-lab4-s3-1 Waiting + Container mtusi-lab4-s3-1 Healthy + Container mtusi-lab4-postgres-1 Healthy + Container mtusi-lab4-s3-init-1 Starting + Container mtusi-lab4-migrate-1 Starting + Container mtusi-lab4-migrate-1 Started + Container mtusi-lab4-s3-init-1 Started + Container mtusi-lab4-migrate-1 Waiting + Container mtusi-lab4-s3-init-1 Waiting + Container mtusi-lab4-postgres-1 Waiting + Container mtusi-lab4-postgres-1 Healthy + Container mtusi-lab4-migrate-1 Exited + Container mtusi-lab4-s3-init-1 Exited + Container mtusi-lab4-api-1 Starting + Container mtusi-lab4-api-1 Started +[exit 0] + +$ C:\Users\79152\AppData\Local\Python\pythoncore-3.14-64\python.exe tests/resilience.py --mode failover --action-script C:\Users\79152\Downloads\mtusi2026lab4-solution (1)\mtusi2026lab4\scripts\stop-one.cmd --base-url http://localhost:8080 +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 115, "failed_attempts": 0, "first_recovery_seconds": 1.843} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +[exit 0] + +$ C:\Users\79152\Downloads\mtusi2026lab4-solution (1)\mtusi2026lab4\scripts\restore-api.cmd + Container mtusi-lab4-s3-1 Waiting + Container mtusi-lab4-postgres-1 Waiting + Container mtusi-lab4-postgres-1 Healthy + Container mtusi-lab4-migrate-1 Starting + Container mtusi-lab4-s3-1 Healthy + Container mtusi-lab4-s3-init-1 Starting + Container mtusi-lab4-s3-init-1 Started + Container mtusi-lab4-migrate-1 Started + Container mtusi-lab4-migrate-1 Waiting + Container mtusi-lab4-s3-init-1 Waiting + Container mtusi-lab4-postgres-1 Waiting + Container mtusi-lab4-postgres-1 Healthy + Container mtusi-lab4-migrate-1 Exited + Container mtusi-lab4-s3-init-1 Exited + Container mtusi-lab4-api-1 Starting + Container mtusi-lab4-api-1 Started +[exit 0] diff --git a/evidence/no-local-file.txt b/evidence/no-local-file.txt new file mode 100644 index 00000000..c8bcf66a --- /dev/null +++ b/evidence/no-local-file.txt @@ -0,0 +1,15 @@ +# no-local-file +# date: 2026-10-29T19:36:27 commit: no-git + +$ docker compose --env-file .env exec -T --index 1 api python -m app.tools find-local 99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75 +{"files_scanned": 52, "copies_found": []} +[exit 0] + +$ docker compose --env-file .env exec -T --index 2 api python -m app.tools find-local 99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75 +{"files_scanned": 52, "copies_found": []} +[exit 0] + +$ docker inspect -f {{.Name}} mounts={{json .Mounts}} 807f1011fecb89bb1de9c29b42976ef462f61b37b4acf474f5e3d4123f0b86a2 3b090ba3d3a9293dcef2063f61491adafbe302578252bc499aead98c39dcc3da +/mtusi-lab4-api-1 mounts=[] +/mtusi-lab4-api-2 mounts=[] +[exit 0] diff --git a/evidence/orphans.txt b/evidence/orphans.txt new file mode 100644 index 00000000..09554692 --- /dev/null +++ b/evidence/orphans.txt @@ -0,0 +1,45 @@ +# orphans +# date: 2026-10-29T19:36:33 commit: no-git + +$ docker compose --env-file .env --profile fault up -d api-fault + Container mtusi-lab4-postgres-1 Running + Container mtusi-lab4-api-fault-1 Recreate + Container mtusi-lab4-api-fault-1 Recreated + Container mtusi-lab4-postgres-1 Waiting + Container mtusi-lab4-postgres-1 Healthy + Container mtusi-lab4-api-fault-1 Starting + Container mtusi-lab4-api-fault-1 Started +[exit 0] + +$ C:\Users\79152\AppData\Local\Python\pythoncore-3.14-64\python.exe student-tests/orphans.py --base-url http://localhost:8080 --fault-url http://localhost:8082 + ok - fault replica (profile fault) is ready on --fault-url + ok - committed attachment that must survive every cleanup + baseline: {'objects': 35, 'attachments': 35, 'upload_intents': 0} +== 1. прерванная загрузка == + ok - no object, no metadata, no journal row after interrupted upload ({'objects': 35, 'attachments': 35, 'upload_intents': 0}) +== 2. отказ БД после PUT: немедленная компенсация == + ok - upload answered 503, not 201 (got 503) + ok - object deleted by compensation, journal clean ({'objects': 35, 'attachments': 35, 'upload_intents': 0}) +== 3. процесс убит между PUT и COMMIT == + ok - client did NOT get 201 (got 502) + ok - orphan object + journal row left behind, no metadata ({'objects': 36, 'attachments': 35, 'upload_intents': 1}) + ok - default grace 900 s: fresh upload is NOT touched + ok - dry-run reports 1 object, changes nothing + ok - janitor removed orphan + journal row ({'grace_seconds': 5, 'dry_run': False, 'locked': True, 'intents_expired': 1, 'intents_removed': 1, 'objects_deleted': 1, 'would_delete_objects': 0, 'orphans_found': 0, 'errors': 0, 'duration_ms': 33.0}) + ok - second run is a no-op (idempotent) +== 4. объект без журнала (страховочный обход bucket) == + ok - untracked object planted + ok - scan with grace 1 h ignores a fresh object + ok - scan dry-run finds 1 + ok - scan deletes the untracked object ({'grace_seconds': 5, 'dry_run': False, 'locked': True, 'intents_expired': 0, 'intents_removed': 0, 'objects_deleted': 1, 'would_delete_objects': 0, 'orphans_found': 1, 'errors': 0, 'objects_scanned': 36, 'duration_ms': 86.7}) +== 5. готовые вложения не тронуты == + ok - committed attachment still downloads, sha256 matches + ok - object + metadata, no journal row ({'object_exists': True, 'attachment_row': True, 'upload_intent': False}) + +17 passed, 0 failed +[exit 0] + +$ docker compose --env-file .env --profile fault stop api-fault + Container mtusi-lab4-api-fault-1 Stopping + Container mtusi-lab4-api-fault-1 Stopped +[exit 0] diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..dd4a2d2c --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,27 @@ +# persistence +# date: 2026-10-29T19:39:19 commit: no-git + +$ docker compose --env-file .env ps +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-lab4-api-1 mtusi-messenger:lab4 "python -m app" api 5 minutes ago Up 5 minutes (healthy) 8080/tcp +mtusi-lab4-api-2 mtusi-messenger:lab4 "python -m app" api 5 minutes ago Up 5 minutes (healthy) 8080/tcp +mtusi-lab4-lb-1 haproxy:3.0.5-alpine "docker-entrypoint.s…" lb 20 minutes ago Up 11 minutes (healthy) 127.0.0.1:8080-8082->8080-8082/tcp +mtusi-lab4-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 20 minutes ago Up 11 minutes (healthy) 5432/tcp +mtusi-lab4-redis-1 redis:7.4.1-alpine "docker-entrypoint.s…" redis 20 minutes ago Up 11 minutes (healthy) 6379/tcp +mtusi-lab4-s3-1 pgsty/minio:RELEASE.2026-08-04T00-00-00Z "/usr/bin/docker-ent…" s3 20 minutes ago Up 51 seconds (healthy) 9000/tcp +[exit 0] + +$ C:\Users\79152\AppData\Local\Python\pythoncore-3.14-64\python.exe tests/resilience.py --mode persistence --action-script C:\Users\79152\Downloads\mtusi2026lab4-solution (1)\mtusi2026lab4\scripts\restart.cmd --base-url http://localhost: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. +[exit 0] + +$ docker compose --env-file .env ps +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-lab4-api-1 mtusi-messenger:lab4 "python -m app" api 5 minutes ago Up 5 seconds (health: starting) 8080/tcp +mtusi-lab4-api-2 mtusi-messenger:lab4 "python -m app" api 5 minutes ago Up 4 seconds (health: starting) 8080/tcp +mtusi-lab4-lb-1 haproxy:3.0.5-alpine "docker-entrypoint.s…" lb 21 minutes ago Up 3 seconds (health: starting) 127.0.0.1:8080-8082->8080-8082/tcp +mtusi-lab4-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 21 minutes ago Up 5 seconds (health: starting) 5432/tcp +mtusi-lab4-redis-1 redis:7.4.1-alpine "docker-entrypoint.s…" redis 21 minutes ago Up 7 seconds (healthy) 6379/tcp +mtusi-lab4-s3-1 pgsty/minio:RELEASE.2026-08-04T00-00-00Z "/usr/bin/docker-ent…" s3 21 minutes ago Up 5 seconds (health: starting) 9000/tcp +[exit 0] diff --git a/evidence/s3-bootstrap.txt b/evidence/s3-bootstrap.txt new file mode 100644 index 00000000..b62dd84f --- /dev/null +++ b/evidence/s3-bootstrap.txt @@ -0,0 +1,30 @@ +# s3-bootstrap +# date: 2026-10-29T19:36:13 commit: no-git + +$ docker compose --env-file .env run --rm s3-init + Container mtusi-lab4-s3-1 Running + Container mtusi-lab4-s3-1 Waiting + Container mtusi-lab4-s3-1 Healthy + Container mtusi-lab4-s3-init-run-653b9b4a6219 Creating + Container mtusi-lab4-s3-init-run-653b9b4a6219 Created +Bucket created successfully `root/messenger-attachments`. +Access permission for `root/messenger-attachments` is set to `private` +policy lab4-api-rw attached to API user +verified: API user has policy lab4-api-rw +Access permission for `root/messenger-attachments` is `private` +bootstrap done: bucket=messenger-attachments (private), API user restricted by policy lab4-api-rw +[exit 0] + +$ docker compose --env-file .env run --rm s3-init + Container mtusi-lab4-s3-1 Running + Container mtusi-lab4-s3-1 Waiting + Container mtusi-lab4-s3-1 Healthy + Container mtusi-lab4-s3-init-run-5831f8c376db Creating + Container mtusi-lab4-s3-init-run-5831f8c376db Created +Bucket created successfully `root/messenger-attachments`. +Access permission for `root/messenger-attachments` is set to `private` +policy lab4-api-rw attached to API user +verified: API user has policy lab4-api-rw +Access permission for `root/messenger-attachments` is `private` +bootstrap done: bucket=messenger-attachments (private), API user restricted by policy lab4-api-rw +[exit 0] diff --git a/evidence/s3-outage.txt b/evidence/s3-outage.txt new file mode 100644 index 00000000..e00a2b3b --- /dev/null +++ b/evidence/s3-outage.txt @@ -0,0 +1,21 @@ +# s3-outage +# date: 2026-10-29T19:49:31 commit: no-git + +$ C:\Users\79152\AppData\Local\Python\pythoncore-3.14-64\python.exe student-tests/s3_outage.py --base-url http://localhost:8080 + ok - upload before outage +== MinIO остановлен == + ok - upload -> 503 unavailable (got 503) + ok - bounded by timeouts, not a hang (4.4 s) + ok - download -> 503 (got 503) + ok - metadata still served from PostgreSQL + ok - text messages still work + ok - message referencing an existing attachment still works (metadata only) + ok - /health/ready = 200 (S3 is not critical for text path) +== MinIO снова работает == + ok - file uploaded before outage downloads unchanged + ok - uploads work again on all replicas: 4 x 201 in a row after 5.1 s (codes during recovery: [503, 201, 503, 201, 503, 201, 503, 201, 503, 201, 503, 201, 503, 201, 503, 201, 201, 201, 201]) + stats: {'objects': 152, 'attachments': 152, 'upload_intents': 1} + ok - janitor cleaned journal rows left by failed uploads ({'grace_seconds': 0, 'dry_run': False, 'locked': True, 'intents_expired': 1, 'intents_removed': 1, 'objects_deleted': 1, 'would_delete_objects': 0, 'orphans_found': 0, 'errors': 0, 'duration_ms': 75.2}) + +11 passed, 0 failed +[exit 0] diff --git a/evidence/s3-private.txt b/evidence/s3-private.txt new file mode 100644 index 00000000..0f6bbc9f --- /dev/null +++ b/evidence/s3-private.txt @@ -0,0 +1,17 @@ +# s3-private +# date: 2026-10-29T19:36:21 commit: no-git + +$ docker compose --env-file .env exec -T api python -m app.tools private-check + ok API credentials: GET own object -> 200 + ok anonymous GET object -> 403 + ok anonymous LIST bucket -> 403 + ok anonymous PUT object -> 403 + ok API credentials: ListBuckets (no foreign buckets) -> only messenger-attachments + ok API credentials: CreateBucket -> AccessDenied + ok API credentials: PutBucketPolicy (make public) -> AccessDenied + ok API credentials: DeleteBucket -> AccessDenied + +8 passed, 0 failed +[exit 0] +127.0.0.1:9000 closed (TimeoutError) ok +127.0.0.1:9001 closed (TimeoutError) ok diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..ae48a1e3 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,6 @@ +# smoke +# date: 2026-10-29T19:34:10 commit: no-git + +$ C:\Users\79152\AppData\Local\Python\pythoncore-3.14-64\python.exe tests/smoke.py --base-url http://localhost:8080 +PASS: lab4 public API scenario; infrastructure and grading evidence remain separate. +[exit 0] diff --git a/evidence/stand.txt b/evidence/stand.txt new file mode 100644 index 00000000..527a8b98 --- /dev/null +++ b/evidence/stand.txt @@ -0,0 +1,26 @@ +# stand +# date: 2026-10-29T19:49:28 commit: no-git + +$ docker compose --env-file .env ps +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-lab4-api-1 mtusi-messenger:lab4 "python -m app" api 9 seconds ago Up 2 seconds (health: starting) 8080/tcp +mtusi-lab4-api-2 mtusi-messenger:lab4 "python -m app" api 9 seconds ago Up 2 seconds (health: starting) 8080/tcp +mtusi-lab4-lb-1 haproxy:3.0.5-alpine "docker-entrypoint.s…" lb 30 minutes ago Up 10 minutes (healthy) 127.0.0.1:8080-8082->8080-8082/tcp +mtusi-lab4-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 31 minutes ago Up 10 minutes (healthy) 5432/tcp +mtusi-lab4-redis-1 redis:7.4.1-alpine "docker-entrypoint.s…" redis 31 minutes ago Up 10 minutes (healthy) 6379/tcp +mtusi-lab4-s3-1 pgsty/minio:RELEASE.2026-08-04T00-00-00Z "/usr/bin/docker-ent…" s3 31 minutes ago Up 3 minutes (healthy) 9000/tcp +[exit 0] + +$ docker compose --env-file .env config --images +pgsty/mc:RELEASE.2026-09-16T00-00-00Z +mtusi-messenger:lab4 +postgres:16.4-alpine +haproxy:3.0.5-alpine +redis:7.4.1-alpine +mtusi-messenger:lab4 +pgsty/minio:RELEASE.2026-08-04T00-00-00Z +[exit 0] + +$ docker compose --env-file .env exec -T api python -m app.migrate +applied: nothing (up to date) +[exit 0] diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 00000000..c5c42cf7 --- /dev/null +++ b/evidence/student-tests.txt @@ -0,0 +1,62 @@ +# student-tests +# date: 2026-10-29T19:34:17 commit: no-git + +$ C:\Users\79152\AppData\Local\Python\pythoncore-3.14-64\python.exe student-tests/run.py --base-url http://localhost:8080 +== аутентификация == + ok - wrong password -> 401 + Basic challenge + ok - unknown user -> 401 (same as wrong password) + ok - no token -> 401 + Bearer challenge + ok - X-User-Id alone gives no access + ok - unknown/forged token -> 401 + ok - Basic on business endpoint -> 401 + ok - X-User-Id cannot override bearer identity + ok - password shorter than 12 -> 400 +== logout == + ok - logout -> 204 + ok - token after logout -> 401 + ok - second logout -> 401 +== гонка регистрации одного username == + ok - 20 parallel registrations -> one 201, nineteen 409 (got [201, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409]) +== ошибки и доступ (из lab1) == + ok - malformed JSON -> 400 + ok - duplicate username -> 409 + ok - blank message -> 400 + ok - sender_id in body is rejected + ok - outsider POST to foreign chat -> 404 + ok - outsider GET foreign history -> 404 + ok - invalid chat uuid -> 400 +== пагинация == + ok - 5 messages / limit 2 -> 3 pages, no duplicates + ok - cursor from another chat -> 400 +== Content-Type == + ok - valid JSON with text/plain -> 415 (got 415) + ok - message with text/plain -> 415 (got 415) + ok - text/plain without token -> 401 first (got 401) + ok - application/json; charset=utf-8 accepted (got 201) + +25 passed, 0 failed +[exit 0] + +$ C:\Users\79152\AppData\Local\Python\pythoncore-3.14-64\python.exe student-tests/idempotency.py --base-url http://localhost:8080 +== 20 параллельных запросов с одним ключом == + ok - all parallel repeats -> 201 (got [201]) + ok - all responses carry the same message id (1 distinct) + ok - requests were served by >=2 replicas (2) + ok - exactly one message in history + ok - every replay returns the identical Message +== семантика ключа == + ok - same key, different body -> 409 (got 409) + ok - other JSON formatting = same request (got 201) + ok - same key in another chat is independent + ok - same key from another user is independent + ok - missing Idempotency-Key -> 400 (got 400) + ok - invalid key 'has space'... -> 400 (got 400) + ok - invalid key 'xxxxxxxxxxxx'... -> 400 (got 400) + ok - invalid key 'slash/key'... -> 400 (got 400) + ok - replay without session -> 401, access re-checked (got 401) +== неопределённый результат: клиент повторяет с тем же ключом == + ok - retry after uncertain result -> 201 + ok - still exactly one message + +16 passed, 0 failed +[exit 0] diff --git a/evidence/upload-memory-10.json b/evidence/upload-memory-10.json new file mode 100644 index 00000000..017f9e57 --- /dev/null +++ b/evidence/upload-memory-10.json @@ -0,0 +1,378 @@ +{ + "file_bytes": 10026738, + "concurrency": 10, + "rounds": 3, + "uploads": 30, + "status_counts": { + "201": 30 + }, + "sha256_ok": 30, + "instances": [ + "3b090ba3d3a9", + "807f1011fecb" + ], + "elapsed_s": 9.54, + "throughput_MiB_s": 30.1, + "latency_s": { + "p50": 2.86, + "max": 3.47 + }, + "memory_MiB": { + "idle": { + "807f1011fecb": { + "usage": 75.3, + "anon": 70.2, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 74.7, + "anon": 69.9, + "peak": 214.0 + } + }, + "sampled_peak": { + "807f1011fecb": { + "usage": 122.8, + "anon": 90.3 + }, + "3b090ba3d3a9": { + "usage": 128.2, + "anon": 91.1 + } + }, + "after": { + "807f1011fecb": { + "usage": 84.4, + "anon": 79.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 83.7, + "anon": 79.0, + "peak": 214.0 + } + }, + "max_growth_usage": 53.5, + "max_growth_anon": 21.2, + "cgroup_peak_after": { + "807f1011fecb": 214.2, + "3b090ba3d3a9": 214.0 + } + }, + "container_limit_MiB": 256, + "samples": 24, + "raw_samples": [ + { + "t": 0.28, + "807f1011fecb": { + "usage": 76.4, + "anon": 72.0, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 75.6, + "anon": 72.2, + "peak": 214.0 + } + }, + { + "t": 0.95, + "807f1011fecb": { + "usage": 79.7, + "anon": 75.8, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 77.0, + "anon": 73.7, + "peak": 214.0 + } + }, + { + "t": 1.56, + "807f1011fecb": { + "usage": 90.8, + "anon": 83.6, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 89.4, + "anon": 73.5, + "peak": 214.0 + } + }, + { + "t": 2.16, + "807f1011fecb": { + "usage": 102.2, + "anon": 87.0, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 98.1, + "anon": 74.3, + "peak": 214.0 + } + }, + { + "t": 2.75, + "807f1011fecb": { + "usage": 114.1, + "anon": 90.3, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 119.8, + "anon": 87.8, + "peak": 214.0 + } + }, + { + "t": 3.24, + "807f1011fecb": { + "usage": 116.8, + "anon": 76.8, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 95.9, + "anon": 91.1, + "peak": 214.0 + } + }, + { + "t": 3.78, + "807f1011fecb": { + "usage": 85.1, + "anon": 79.5, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 87.1, + "anon": 82.0, + "peak": 214.0 + } + }, + { + "t": 4.35, + "807f1011fecb": { + "usage": 87.3, + "anon": 81.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 88.4, + "anon": 82.9, + "peak": 214.0 + } + }, + { + "t": 4.86, + "807f1011fecb": { + "usage": 87.4, + "anon": 81.0, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 84.9, + "anon": 78.4, + "peak": 214.0 + } + }, + { + "t": 5.37, + "807f1011fecb": { + "usage": 100.5, + "anon": 76.9, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 101.5, + "anon": 78.7, + "peak": 214.0 + } + }, + { + "t": 5.84, + "807f1011fecb": { + "usage": 120.9, + "anon": 78.8, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 128.2, + "anon": 78.8, + "peak": 214.0 + } + }, + { + "t": 6.24, + "807f1011fecb": { + "usage": 120.8, + "anon": 78.9, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 119.8, + "anon": 78.7, + "peak": 214.0 + } + }, + { + "t": 6.86, + "807f1011fecb": { + "usage": 88.0, + "anon": 82.9, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 87.8, + "anon": 83.3, + "peak": 214.0 + } + }, + { + "t": 7.46, + "807f1011fecb": { + "usage": 89.9, + "anon": 83.4, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 89.3, + "anon": 83.2, + "peak": 214.0 + } + }, + { + "t": 8.05, + "807f1011fecb": { + "usage": 99.3, + "anon": 83.7, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 95.9, + "anon": 78.9, + "peak": 214.0 + } + }, + { + "t": 8.76, + "807f1011fecb": { + "usage": 111.1, + "anon": 88.4, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 109.8, + "anon": 88.0, + "peak": 214.0 + } + }, + { + "t": 9.26, + "807f1011fecb": { + "usage": 122.8, + "anon": 90.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 121.4, + "anon": 89.0, + "peak": 214.0 + } + }, + { + "t": 9.66, + "807f1011fecb": { + "usage": 84.6, + "anon": 79.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 84.1, + "anon": 79.1, + "peak": 214.0 + } + }, + { + "t": 10.0, + "807f1011fecb": { + "usage": 84.6, + "anon": 79.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 84.0, + "anon": 79.1, + "peak": 214.0 + } + }, + { + "t": 10.34, + "807f1011fecb": { + "usage": 84.6, + "anon": 79.0, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 83.9, + "anon": 79.1, + "peak": 214.0 + } + }, + { + "t": 10.68, + "807f1011fecb": { + "usage": 84.5, + "anon": 79.0, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 83.6, + "anon": 79.0, + "peak": 214.0 + } + }, + { + "t": 11.0, + "807f1011fecb": { + "usage": 84.5, + "anon": 79.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 83.9, + "anon": 79.0, + "peak": 214.0 + } + }, + { + "t": 11.34, + "807f1011fecb": { + "usage": 84.6, + "anon": 79.0, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 83.8, + "anon": 79.1, + "peak": 214.0 + } + }, + { + "t": 11.69, + "807f1011fecb": { + "usage": 84.4, + "anon": 79.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 84.0, + "anon": 79.1, + "peak": 214.0 + } + } + ] +} \ No newline at end of file diff --git a/evidence/upload-memory-20.json b/evidence/upload-memory-20.json new file mode 100644 index 00000000..9523455e --- /dev/null +++ b/evidence/upload-memory-20.json @@ -0,0 +1,599 @@ +{ + "file_bytes": 10026844, + "concurrency": 20, + "rounds": 3, + "uploads": 60, + "status_counts": { + "201": 60 + }, + "sha256_ok": 60, + "instances": [ + "3b090ba3d3a9", + "807f1011fecb" + ], + "elapsed_s": 20.12, + "throughput_MiB_s": 28.5, + "latency_s": { + "p50": 5.39, + "max": 7.81 + }, + "memory_MiB": { + "idle": { + "807f1011fecb": { + "usage": 84.5, + "anon": 79.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 83.8, + "anon": 79.0, + "peak": 214.0 + } + }, + "sampled_peak": { + "807f1011fecb": { + "usage": 156.0, + "anon": 104.2 + }, + "3b090ba3d3a9": { + "usage": 156.7, + "anon": 105.5 + } + }, + "after": { + "807f1011fecb": { + "usage": 92.1, + "anon": 86.4, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 91.2, + "anon": 86.4, + "peak": 214.0 + } + }, + "max_growth_usage": 72.9, + "max_growth_anon": 26.5, + "cgroup_peak_after": { + "807f1011fecb": 214.2, + "3b090ba3d3a9": 214.0 + } + }, + "container_limit_MiB": 256, + "samples": 41, + "raw_samples": [ + { + "t": 0.36, + "807f1011fecb": { + "usage": 87.5, + "anon": 82.7, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 85.8, + "anon": 80.8, + "peak": 214.0 + } + }, + { + "t": 0.88, + "807f1011fecb": { + "usage": 92.2, + "anon": 86.3, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 90.6, + "anon": 86.0, + "peak": 214.0 + } + }, + { + "t": 1.54, + "807f1011fecb": { + "usage": 93.9, + "anon": 87.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 92.6, + "anon": 85.9, + "peak": 214.0 + } + }, + { + "t": 2.05, + "807f1011fecb": { + "usage": 95.7, + "anon": 88.2, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 93.5, + "anon": 86.0, + "peak": 214.0 + } + }, + { + "t": 2.64, + "807f1011fecb": { + "usage": 92.2, + "anon": 83.9, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 93.6, + "anon": 86.1, + "peak": 214.0 + } + }, + { + "t": 3.15, + "807f1011fecb": { + "usage": 109.2, + "anon": 83.8, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 113.5, + "anon": 86.2, + "peak": 214.0 + } + }, + { + "t": 3.83, + "807f1011fecb": { + "usage": 115.8, + "anon": 84.8, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 115.0, + "anon": 86.0, + "peak": 214.0 + } + }, + { + "t": 4.65, + "807f1011fecb": { + "usage": 123.6, + "anon": 95.2, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 126.9, + "anon": 95.6, + "peak": 214.0 + } + }, + { + "t": 5.45, + "807f1011fecb": { + "usage": 131.5, + "anon": 97.2, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 127.2, + "anon": 97.3, + "peak": 214.0 + } + }, + { + "t": 6.17, + "807f1011fecb": { + "usage": 122.2, + "anon": 98.4, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 107.9, + "anon": 86.2, + "peak": 214.0 + } + }, + { + "t": 7.05, + "807f1011fecb": { + "usage": 90.6, + "anon": 86.0, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 86.8, + "anon": 82.0, + "peak": 214.0 + } + }, + { + "t": 7.8, + "807f1011fecb": { + "usage": 91.8, + "anon": 86.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 88.4, + "anon": 84.9, + "peak": 214.0 + } + }, + { + "t": 8.27, + "807f1011fecb": { + "usage": 93.0, + "anon": 85.9, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 91.8, + "anon": 85.8, + "peak": 214.0 + } + }, + { + "t": 8.75, + "807f1011fecb": { + "usage": 95.9, + "anon": 88.7, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 93.0, + "anon": 86.8, + "peak": 214.0 + } + }, + { + "t": 9.26, + "807f1011fecb": { + "usage": 97.0, + "anon": 89.0, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 95.2, + "anon": 87.8, + "peak": 214.0 + } + }, + { + "t": 9.74, + "807f1011fecb": { + "usage": 100.2, + "anon": 84.6, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 89.6, + "anon": 80.3, + "peak": 214.0 + } + }, + { + "t": 10.24, + "807f1011fecb": { + "usage": 117.3, + "anon": 84.6, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 105.5, + "anon": 80.3, + "peak": 214.0 + } + }, + { + "t": 10.74, + "807f1011fecb": { + "usage": 129.3, + "anon": 86.5, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 125.0, + "anon": 82.2, + "peak": 214.0 + } + }, + { + "t": 11.34, + "807f1011fecb": { + "usage": 141.8, + "anon": 89.9, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 135.6, + "anon": 86.4, + "peak": 214.0 + } + }, + { + "t": 12.14, + "807f1011fecb": { + "usage": 145.7, + "anon": 99.0, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 151.5, + "anon": 94.2, + "peak": 214.0 + } + }, + { + "t": 12.63, + "807f1011fecb": { + "usage": 155.6, + "anon": 86.7, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 156.7, + "anon": 96.7, + "peak": 214.0 + } + }, + { + "t": 12.97, + "807f1011fecb": { + "usage": 156.0, + "anon": 86.7, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 144.0, + "anon": 84.4, + "peak": 214.0 + } + }, + { + "t": 13.31, + "807f1011fecb": { + "usage": 155.8, + "anon": 86.7, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 143.9, + "anon": 84.4, + "peak": 214.0 + } + }, + { + "t": 13.65, + "807f1011fecb": { + "usage": 147.0, + "anon": 86.7, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 134.8, + "anon": 84.4, + "peak": 214.0 + } + }, + { + "t": 14.01, + "807f1011fecb": { + "usage": 137.7, + "anon": 86.7, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 116.6, + "anon": 84.4, + "peak": 214.0 + } + }, + { + "t": 14.55, + "807f1011fecb": { + "usage": 93.5, + "anon": 87.9, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 92.4, + "anon": 87.8, + "peak": 214.0 + } + }, + { + "t": 15.14, + "807f1011fecb": { + "usage": 98.1, + "anon": 91.9, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 98.0, + "anon": 92.3, + "peak": 214.0 + } + }, + { + "t": 15.77, + "807f1011fecb": { + "usage": 99.3, + "anon": 93.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 98.8, + "anon": 92.4, + "peak": 214.0 + } + }, + { + "t": 16.33, + "807f1011fecb": { + "usage": 101.0, + "anon": 93.0, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 100.2, + "anon": 92.8, + "peak": 214.0 + } + }, + { + "t": 16.93, + "807f1011fecb": { + "usage": 117.9, + "anon": 93.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 114.2, + "anon": 93.0, + "peak": 214.0 + } + }, + { + "t": 17.53, + "807f1011fecb": { + "usage": 133.7, + "anon": 98.9, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 126.9, + "anon": 92.9, + "peak": 214.0 + } + }, + { + "t": 18.34, + "807f1011fecb": { + "usage": 126.4, + "anon": 103.0, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 116.4, + "anon": 97.7, + "peak": 214.0 + } + }, + { + "t": 18.94, + "807f1011fecb": { + "usage": 143.1, + "anon": 104.2, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 139.2, + "anon": 104.1, + "peak": 214.0 + } + }, + { + "t": 19.64, + "807f1011fecb": { + "usage": 125.4, + "anon": 93.2, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 135.5, + "anon": 105.5, + "peak": 214.0 + } + }, + { + "t": 19.98, + "807f1011fecb": { + "usage": 126.2, + "anon": 93.2, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 116.3, + "anon": 93.1, + "peak": 214.0 + } + }, + { + "t": 20.32, + "807f1011fecb": { + "usage": 92.1, + "anon": 86.5, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 91.2, + "anon": 86.4, + "peak": 214.0 + } + }, + { + "t": 20.66, + "807f1011fecb": { + "usage": 92.1, + "anon": 86.5, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 91.6, + "anon": 86.4, + "peak": 214.0 + } + }, + { + "t": 20.99, + "807f1011fecb": { + "usage": 92.0, + "anon": 86.5, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 91.1, + "anon": 86.4, + "peak": 214.0 + } + }, + { + "t": 21.34, + "807f1011fecb": { + "usage": 92.1, + "anon": 86.4, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 91.4, + "anon": 86.4, + "peak": 214.0 + } + }, + { + "t": 21.66, + "807f1011fecb": { + "usage": 91.9, + "anon": 86.4, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 91.4, + "anon": 86.4, + "peak": 214.0 + } + }, + { + "t": 21.99, + "807f1011fecb": { + "usage": 91.9, + "anon": 86.5, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 91.2, + "anon": 86.4, + "peak": 214.0 + } + } + ] +} \ No newline at end of file diff --git a/evidence/upload-memory.txt b/evidence/upload-memory.txt new file mode 100644 index 00000000..75438150 --- /dev/null +++ b/evidence/upload-memory.txt @@ -0,0 +1,156 @@ +# upload-memory +# date: 2026-10-29T19:38:36 commit: no-git + +$ C:\Users\79152\AppData\Local\Python\pythoncore-3.14-64\python.exe student-tests/upload_memory.py --base-url http://localhost:8080 --concurrency 10 --output evidence/upload-memory-10.json +file: 10026738 bytes (9.56 MiB), sha256 56a8ce1a2d78… +idle MiB: {'807f1011fecb': {'usage': 75.3, 'anon': 70.2, 'peak': 214.2}, '3b090ba3d3a9': {'usage': 74.7, 'anon': 69.9, 'peak': 214.0}} +{ + "file_bytes": 10026738, + "concurrency": 10, + "rounds": 3, + "uploads": 30, + "status_counts": { + "201": 30 + }, + "sha256_ok": 30, + "instances": [ + "3b090ba3d3a9", + "807f1011fecb" + ], + "elapsed_s": 9.54, + "throughput_MiB_s": 30.1, + "latency_s": { + "p50": 2.86, + "max": 3.47 + }, + "memory_MiB": { + "idle": { + "807f1011fecb": { + "usage": 75.3, + "anon": 70.2, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 74.7, + "anon": 69.9, + "peak": 214.0 + } + }, + "sampled_peak": { + "807f1011fecb": { + "usage": 122.8, + "anon": 90.3 + }, + "3b090ba3d3a9": { + "usage": 128.2, + "anon": 91.1 + } + }, + "after": { + "807f1011fecb": { + "usage": 84.4, + "anon": 79.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 83.7, + "anon": 79.0, + "peak": 214.0 + } + }, + "max_growth_usage": 53.5, + "max_growth_anon": 21.2, + "cgroup_peak_after": { + "807f1011fecb": 214.2, + "3b090ba3d3a9": 214.0 + } + }, + "container_limit_MiB": 256 +} + ok - download af982c40 sha256 matches + ok - download 8f84d5ce sha256 matches + ok - download 29e19f9a sha256 matches + ok - all 30 uploads -> 201 + ok - sha256 of every upload matches + ok - peak growth per replica 53.5 MiB < 100 MiB (naive buffering: ≥ 5 × 9.6 MiB × 2) +saved evidence/upload-memory-10.json + +6 passed, 0 failed +[exit 0] + +$ C:\Users\79152\AppData\Local\Python\pythoncore-3.14-64\python.exe student-tests/upload_memory.py --base-url http://localhost:8080 --concurrency 20 --output evidence/upload-memory-20.json +file: 10026844 bytes (9.56 MiB), sha256 5f839924b002… +idle MiB: {'807f1011fecb': {'usage': 84.5, 'anon': 79.1, 'peak': 214.2}, '3b090ba3d3a9': {'usage': 83.8, 'anon': 79.0, 'peak': 214.0}} +{ + "file_bytes": 10026844, + "concurrency": 20, + "rounds": 3, + "uploads": 60, + "status_counts": { + "201": 60 + }, + "sha256_ok": 60, + "instances": [ + "3b090ba3d3a9", + "807f1011fecb" + ], + "elapsed_s": 20.12, + "throughput_MiB_s": 28.5, + "latency_s": { + "p50": 5.39, + "max": 7.81 + }, + "memory_MiB": { + "idle": { + "807f1011fecb": { + "usage": 84.5, + "anon": 79.1, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 83.8, + "anon": 79.0, + "peak": 214.0 + } + }, + "sampled_peak": { + "807f1011fecb": { + "usage": 156.0, + "anon": 104.2 + }, + "3b090ba3d3a9": { + "usage": 156.7, + "anon": 105.5 + } + }, + "after": { + "807f1011fecb": { + "usage": 92.1, + "anon": 86.4, + "peak": 214.2 + }, + "3b090ba3d3a9": { + "usage": 91.2, + "anon": 86.4, + "peak": 214.0 + } + }, + "max_growth_usage": 72.9, + "max_growth_anon": 26.5, + "cgroup_peak_after": { + "807f1011fecb": 214.2, + "3b090ba3d3a9": 214.0 + } + }, + "container_limit_MiB": 256 +} + ok - download 86ee3302 sha256 matches + ok - download 4566fa4d sha256 matches + ok - download e1a5b504 sha256 matches + ok - all 60 uploads -> 201 + ok - sha256 of every upload matches + ok - peak growth per replica 72.9 MiB < 100 MiB (naive buffering: ≥ 10 × 9.6 MiB × 2) +saved evidence/upload-memory-20.json + +6 passed, 0 failed +[exit 0] diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 00000000..285590d9 --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -0,0 +1,84 @@ +# Балансировщик lab3/lab4: единственная публичная точка входа (127.0.0.1:8080). +# Реплики API находятся через DNS Docker по имени сервиса "api" +# (server-template + resolvers): добавление/удаление контейнеров подхватывается +# без перезапуска LB. Активная проверка /health/ready исключает недоступную реплику. +global + log stdout format raw local0 info + maxconn 2048 + +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 5s + hold other 5s + hold refused 5s + hold nx 5s + hold timeout 5s + hold obsolete 5s + accepted_payload_size 8192 + +defaults + mode http + log global + option httplog + # Короткий connect: остановленный контейнер не отвечает на SYN, и без этого + # запрос ждал бы 2 c до повтора на другой реплике. + timeout connect 500ms + timeout client 30s + timeout server 30s + timeout http-request 10s + # Повтор только при ошибке УСТАНОВКИ соединения (запрос ещё не отправлен) — + # безопасно даже для POST; redispatch отправляет повтор на другую реплику. + retries 3 + option redispatch + +frontend fe_api + bind :8080 + default_backend api + +# Отдельный вход для теста истечения сессии (профиль ttl): тоже только через LB. +frontend fe_api_ttl + bind :8081 + default_backend api_ttl + +# lab4: вход в реплику с внедрением отказов (профиль fault) — только для тестов +# компенсации/очистки (student-tests/orphans.py). Обычный трафик сюда не идёт. +frontend fe_api_fault + bind :8082 + default_backend api_fault + +# Проверка живости самого LB для healthcheck контейнера. +frontend fe_health + bind :8404 + monitor-uri /healthz + +backend api + balance roundrobin + option httpchk GET /health/ready + http-check expect status 200 + # Проверка раз в 0,5 c; 2 неудачи подряд → реплика исключается (≈1–1,5 c), + # 2 успеха подряд → возвращается. + default-server inter 500ms fall 2 rise 2 resolvers docker init-addr none + server-template api 6 api:8080 check + # Запасной путь, только если НИ ОДНА реплика не готова (например, упала общая БД): + # тогда LB всё равно передаёт запрос в живой процесс, и API отвечает по контракту + # (401 анониму, 503 unavailable в формате ошибки, /health/live 200), а не голым 503 LB. + # Остановленный контейнер исчезает из DNS и сюда не попадает. + option allbackups + # allow-dup-ip: те же IP, что у основных серверов (по умолчанию HAProxy не даёт + # одному IP достаться двум серверам бэкенда, и резервные остались бы без адреса). + server-template fallback 6 api:8080 backup resolve-opts allow-dup-ip + +backend api_ttl + option httpchk GET /health/ready + http-check expect status 200 + default-server check inter 500ms fall 2 rise 2 resolvers docker init-addr none + server-template ttl 2 api-ttl:8080 + +backend api_fault + option httpchk GET /health/ready + http-check expect status 200 + default-server check inter 500ms fall 2 rise 2 resolvers docker init-addr none + server-template fault 1 api-fault:8080 diff --git a/infra/minio/bootstrap.sh b/infra/minio/bootstrap.sh new file mode 100644 index 00000000..2ddab729 --- /dev/null +++ b/infra/minio/bootstrap.sh @@ -0,0 +1,56 @@ +#!/bin/sh +# Идемпотентный bootstrap MinIO (сервис s3-init, запускается при каждом `up`). +# 1. bucket (если уже есть — не ошибка); +# 2. bucket приватный: анонимный доступ «none»; +# 3. политика lab4-api-rw: только Get/Put/Delete объектов и List этого bucket; +# 4. отдельный пользователь API (S3_ACCESS_KEY_ID) с этой политикой. +# Root-пользователь MinIO нужен только здесь. Секреты не печатаются. +set -eu +: "${MINIO_ROOT_USER:?}" "${MINIO_ROOT_PASSWORD:?}" "${S3_BUCKET:?}" +: "${S3_ACCESS_KEY_ID:?}" "${S3_SECRET_ACCESS_KEY:?}" +if [ "$S3_ACCESS_KEY_ID" = "$MINIO_ROOT_USER" ]; then + echo "S3_ACCESS_KEY_ID must differ from MINIO_ROOT_USER (least privilege)" >&2 + exit 1 +fi + +mc alias set root http://s3:9000 "$MINIO_ROOT_USER" "$MINIO_ROOT_PASSWORD" >/dev/null + +mc mb --ignore-existing "root/$S3_BUCKET" +mc anonymous set none "root/$S3_BUCKET" + +POLICY_NAME=lab4-api-rw +cat > /tmp/policy.json </dev/null +# add для существующего пользователя обновляет секрет — повтор безопасен. +mc admin user add root "$S3_ACCESS_KEY_ID" "$S3_SECRET_ACCESS_KEY" >/dev/null +# attach для уже привязанной политики возвращает ошибку — это не сбой, проверяем итог ниже. +if mc admin policy attach root "$POLICY_NAME" --user "$S3_ACCESS_KEY_ID" >/dev/null 2>&1; then + echo "policy $POLICY_NAME attached to API user" +else + echo "policy $POLICY_NAME was already attached (attach is a no-op)" +fi +info=$(mc admin user info root "$S3_ACCESS_KEY_ID" --json) +case "$info" in + *\"policyName\"*"$POLICY_NAME"*) echo "verified: API user has policy $POLICY_NAME" ;; + *) echo "API user has NO policy $POLICY_NAME: $info" >&2; exit 1 ;; +esac + +mc anonymous get "root/$S3_BUCKET" +echo "bootstrap done: bucket=$S3_BUCKET (private), API user restricted by policy $POLICY_NAME" diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..229ff8e4 --- /dev/null +++ b/migrations/0001_init.sql @@ -0,0 +1,54 @@ +-- 0001: начальная схема мессенджера (lab2). +-- Источник истины для пользователей, чатов, участников, сообщений и сессий. + +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name text NOT NULL, + password_hash text NOT NULL, + created_at timestamptz NOT NULL, + CONSTRAINT users_username_key UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_len CHECK (char_length(display_name) BETWEEN 1 AND 100) +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_by uuid NOT NULL REFERENCES users (id), + created_at timestamptz NOT NULL, + CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100) +); + +-- Участники чата. position сохраняет порядок member_ids из запроса. +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users (id), + position integer NOT NULL, + PRIMARY KEY (chat_id, user_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 REFERENCES chats (id) ON DELETE CASCADE, + sender_id uuid NOT NULL REFERENCES users (id), + text text NOT NULL, + created_at timestamptz NOT NULL, + CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000) +); +-- Keyset-пагинация истории: WHERE chat_id = $1 AND (created_at, id) > ($2, $3) +-- ORDER BY created_at, id LIMIT n — индекс отдаёт страницу без скана всей истории. +CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); + +-- Сессии. Храним только SHA-256 от токена: утечка таблицы не даёт рабочих токенов. +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users (id), + created_at timestamptz NOT NULL, + expires_at timestamptz NOT NULL, + revoked_at timestamptz +); +CREATE INDEX sessions_user_idx ON sessions (user_id); +CREATE INDEX sessions_expires_idx ON sessions (expires_at); diff --git a/migrations/0002_idempotency.sql b/migrations/0002_idempotency.sql new file mode 100644 index 00000000..9f4bf84f --- /dev/null +++ b/migrations/0002_idempotency.sql @@ -0,0 +1,17 @@ +-- 0002: общая идемпотентность POST /chats/{chat_id}/messages (lab3). +-- Область уникальности ключа: пользователь + чат (метод и путь фиксированы) + ключ. +-- Миграция только добавляет таблицу: старая версия API (lab2) с ней совместима. + +CREATE TABLE idempotency_keys ( + user_id uuid NOT NULL REFERENCES users (id), + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + idem_key text NOT NULL, + request_hash bytea NOT NULL, -- SHA-256 канонического тела запроса + -- Ключ вставляется ДО сообщения в той же транзакции: проверка FK — при COMMIT. + message_id uuid NOT NULL REFERENCES messages (id) DEFERRABLE INITIALLY DEFERRED, + created_at timestamptz NOT NULL, + PRIMARY KEY (user_id, chat_id, idem_key), + CONSTRAINT idempotency_key_format CHECK (idem_key ~ '^[A-Za-z0-9._:-]{1,128}$') +); +-- Для очистки ключей старше IDEMPOTENCY_TTL_SECONDS. +CREATE INDEX idempotency_keys_created_idx ON idempotency_keys (created_at); diff --git a/migrations/0003_attachments.sql b/migrations/0003_attachments.sql new file mode 100644 index 00000000..bc456a25 --- /dev/null +++ b/migrations/0003_attachments.sql @@ -0,0 +1,56 @@ +-- 0003: вложения (lab4). Метаданные — здесь, байты — в приватном S3 bucket. +-- Миграция только добавляет таблицы и ослабляет CHECK текста сообщения: +-- работающая версия lab3 с новой схемой совместима (rolling update возможен). + +-- Текст может быть пустым, если у сообщения есть вложения (проверяет API). +ALTER TABLE messages DROP CONSTRAINT messages_text_len; +ALTER TABLE messages ADD CONSTRAINT messages_text_len CHECK (char_length(text) <= 4000); + +CREATE TABLE attachments ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + owner_id uuid NOT NULL REFERENCES users (id), + -- Только для отображения; в путь/ключ S3 не попадает. + filename text NOT NULL, + content_type text NOT NULL, + size_bytes bigint NOT NULL, + sha256 text NOT NULL, + width integer NOT NULL, + height integer NOT NULL, + status text NOT NULL, + error_code text, + -- Ключ объекта назначает сервер (originals/); уникален. + object_key text NOT NULL, + created_at timestamptz NOT NULL, + updated_at timestamptz NOT NULL, + CONSTRAINT attachments_object_key_key UNIQUE (object_key), + CONSTRAINT attachments_filename_len CHECK (char_length(filename) BETWEEN 1 AND 255), + CONSTRAINT attachments_content_type CHECK (content_type IN ('image/png', 'image/jpeg')), + CONSTRAINT attachments_size CHECK (size_bytes BETWEEN 1 AND 10485760), + CONSTRAINT attachments_sha256 CHECK (sha256 ~ '^[a-f0-9]{64}$'), + CONSTRAINT attachments_dimensions CHECK (width > 0 AND height > 0), + CONSTRAINT attachments_status CHECK (status IN ('queued', 'processing', 'ready', 'failed')) +); +CREATE INDEX attachments_chat_idx ON attachments (chat_id, created_at, id); + +-- Связь сообщение ↔ вложения. position сохраняет порядок attachment_ids из запроса. +-- Одно вложение чата можно приложить к нескольким сообщениям этого чата. +CREATE TABLE message_attachments ( + message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE, + attachment_id uuid NOT NULL REFERENCES attachments (id), + position smallint NOT NULL, + PRIMARY KEY (message_id, attachment_id), + CONSTRAINT message_attachments_position CHECK (position BETWEEN 0 AND 9) +); +CREATE INDEX message_attachments_attachment_idx ON message_attachments (attachment_id); + +-- Журнал загрузок (компенсация отказа между S3 и PostgreSQL). +-- Строка пишется и коммитится ДО PUT в S3, удаляется в одной транзакции +-- с INSERT в attachments. Строка старше grace period = брошенная загрузка: +-- janitor удаляет её объект в S3 (если он есть) и саму строку. +CREATE TABLE upload_intents ( + object_key text PRIMARY KEY, + attachment_id uuid NOT NULL, + created_at timestamptz NOT NULL +); +CREATE INDEX upload_intents_created_idx ON upload_intents (created_at); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..7e05721e --- /dev/null +++ b/requirements.txt @@ -0,0 +1,12 @@ +# Рантайм-зависимости, версии закреплены для воспроизводимой сборки. +fastapi==0.141.1 +uvicorn[standard]==0.46.0 +pydantic==2.13.3 +psycopg[binary]==3.3.6 +psycopg-pool==3.3.3 +argon2-cffi==25.1.0 +redis==8.1.0 +# lab4: S3-клиент (MinIO) и проверка изображений +boto3==1.38.0 +botocore==1.38.0 +pillow==11.2.1 diff --git a/scripts/check-s3-private.cmd b/scripts/check-s3-private.cmd new file mode 100644 index 00000000..8ac03c77 --- /dev/null +++ b/scripts/check-s3-private.cmd @@ -0,0 +1,4 @@ +@echo off +rem Windows: same as check-s3-private.sh +cd /d "%~dp0.." +docker compose --env-file .env exec -T api python -m app.tools private-check %* diff --git a/scripts/check-s3-private.sh b/scripts/check-s3-private.sh new file mode 100644 index 00000000..0c00545f --- /dev/null +++ b/scripts/check-s3-private.sh @@ -0,0 +1,7 @@ +#!/bin/sh +# Проверка приватности bucket и ограниченных прав API ВНЕ API-приложения: +# прямые HTTP-запросы к MinIO без подписи и с ключами API-пользователя. +# Запросы идут из контейнера api (он в сети storage), но НЕ через код эндпоинтов. +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env exec -T api python -m app.tools private-check "$@" diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..54339301 --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,4 @@ +@echo off +rem Restart hook (Windows): same as restart.sh, volumes are kept. +cd /d "%~dp0.." +docker compose --env-file .env restart postgres redis s3 api lb diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..ea899ca7 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,6 @@ +#!/bin/sh +# Restart hook для make test-persistence: перезапускает ВСЕ реплики API, LB и +# хранилища (PostgreSQL, Redis, MinIO). Volumes сохраняются; ничего не удаляется и не сидится. +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env restart postgres redis s3 api lb diff --git a/scripts/restore-api.cmd b/scripts/restore-api.cmd new file mode 100644 index 00000000..e63eb7a0 --- /dev/null +++ b/scripts/restore-api.cmd @@ -0,0 +1,4 @@ +@echo off +rem Restore stopped api replicas after the failover test. +cd /d "%~dp0.." +docker compose --env-file .env start api diff --git a/scripts/restore-api.sh b/scripts/restore-api.sh new file mode 100644 index 00000000..f5d4a8a5 --- /dev/null +++ b/scripts/restore-api.sh @@ -0,0 +1,5 @@ +#!/bin/sh +# Вернуть остановленные реплики API после failover-теста. +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env start api diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 00000000..69f73d98 --- /dev/null +++ b/scripts/stop-one.cmd @@ -0,0 +1,7 @@ +@echo off +rem Failover hook (Windows): stop ONE api container whose short ID = TARGET_INSTANCE_ID. +if "%TARGET_INSTANCE_ID%"=="" exit /b 2 +set CID= +for /f %%i in ('docker ps -q --filter "id=%TARGET_INSTANCE_ID%" --filter "label=com.docker.compose.service=api"') do set CID=%%i +if "%CID%"=="" exit /b 1 +docker stop -t 8 %CID% >nul diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..29224717 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,12 @@ +#!/bin/sh +# Failover hook для make test-failover. +# X-Instance-Id реплики = hostname контейнера = короткий ID контейнера Docker. +# Останавливаем РОВНО этот контейнер, и только если он относится к сервису api +# (БД, Redis и LB этот скрипт не трогает). Реплика остаётся остановленной; +# вернуть её: scripts/restore-api.sh +set -eu +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" +cd "$(dirname "$0")/.." +cid=$(docker ps -q --filter "id=${TARGET_INSTANCE_ID}" --filter "label=com.docker.compose.service=api") +[ -n "$cid" ] || { echo "no running api container for ${TARGET_INSTANCE_ID}" >&2; exit 1; } +docker stop -t 8 "$cid" >/dev/null diff --git a/student-tests/attachments.py b/student-tests/attachments.py new file mode 100644 index 00000000..60a2bb35 --- /dev/null +++ b/student-tests/attachments.py @@ -0,0 +1,259 @@ +#!/usr/bin/env python3 +""" +Вложения lab4: позитивный сценарий и негативный набор уровня «4». + + python student-tests/attachments.py --base-url http://localhost:8080 + +Проверяет (каждый пользовательский промах — ожидаемый 4xx, НИКОГДА не 500): + - PNG и JPEG: 201 ready, sha256/size, скачивание побайтно вторым участником, + истинный Content-Type, Unicode filename, 404 постороннему (метаданные и байты); + - слишком большой файл: по Content-Length (тело не отправляется), chunked без + Content-Length больше лимита, файл ровно в лимит проходит; + - «бомба» по пикселям (маленький файл, > 40 млн пикселей) → 413; + - повреждённые изображения (усечённый PNG/JPEG, битый CRC, мусор) → 415; + - подмена MIME (PNG как image/jpeg, JPEG как image/png, текст/GIF/HTML как png) → 415; + - опасные filename (/, \\, NUL, управляющие, bidi, .., пусто, > 255) → 400; + - чужое attachment_id / вложение другого чата / несуществующее → 404; + дубликаты, > 10 id, не-UUID → 400; пустой текст без вложений → 400; + - идемпотентность с attachment_ids: отсутствие поля == [], другой набор → 409. +""" +import argparse +import uuid +from urllib.parse import quote + +from common import (SAMPLE_JPG, SAMPLE_PNG, Api, Report, make_png, raw_http, sha256, + upload) + +LIMIT = 10 * 1024 * 1024 + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + args = ap.parse_args() + api, r = Api(args.base_url), Report() + statuses: list[int] = [] + + def expect(st, want, name): + statuses.append(st) + want = want if isinstance(want, tuple) else (want,) + r.check(st in want, f"{name} -> {'/'.join(map(str, want))} (got {st})") + + alice, bob, eve = api.new_user("att_a"), api.new_user("att_b"), api.new_user("att_e") + st, chat, _ = api.call("POST", "/api/v1/chats", {"title": "files", "member_ids": [alice["id"], bob["id"]]}, + token=alice["token"]) + st, other, _ = api.call("POST", "/api/v1/chats", {"title": "alice second", "member_ids": [alice["id"]]}, + token=alice["token"]) + st, evechat, _ = api.call("POST", "/api/v1/chats", {"title": "eve", "member_ids": [eve["id"]]}, + token=eve["token"]) + A, B, E = alice["token"], bob["token"], eve["token"] + mpath = f"/api/v1/chats/{chat['id']}/messages" + + print("== позитивный сценарий ==") + st, png, _ = upload(api, A, chat["id"], SAMPLE_PNG, "sample.png") + expect(st, 201, "upload PNG") + r.check(png and png["status"] == "ready" and png["variants"] == [] and png["error_code"] is None, + "201 ready, variants=[], error_code=null") + r.check(png and png["sha256"] == sha256(SAMPLE_PNG) and png["size_bytes"] == len(SAMPLE_PNG), + "sha256/size describe the original") + r.check(png and "object_key" not in png and "bucket" not in str(png), "no S3 key/bucket in public JSON") + st, jpg, _ = upload(api, B, chat["id"], SAMPLE_JPG, "фото 📷 отпуск.jpg", "image/jpeg") + expect(st, 201, "upload JPEG with Unicode filename") + r.check(jpg and jpg["filename"] == "фото 📷 отпуск.jpg" and jpg["content_type"] == "image/jpeg", + "filename returned as is (display only)") + st, raw, rh = api.raw("GET", f"/api/v1/attachments/{png['id']}/content", headers={"Authorization": "Bearer " + B}) + expect(st, 200, "member downloads PNG") + r.check(raw == SAMPLE_PNG and sha256(raw) == png["sha256"], "downloaded bytes are identical (sha256)") + r.check(rh.get("Content-Type", "").startswith("image/png"), "true Content-Type image/png") + r.check(rh.get("X-Content-Type-Options") == "nosniff", "nosniff header") + st, raw, rh = api.raw("GET", f"/api/v1/attachments/{jpg['id']}/content?variant=original", + headers={"Authorization": "Bearer " + A}) + expect(st, 200, "member downloads JPEG (variant=original)") + r.check(raw == SAMPLE_JPG and rh.get("Content-Type", "").startswith("image/jpeg"), "JPEG bytes and type") + st, msg, _ = api.call("POST", mpath, {"text": "", "attachment_ids": [png["id"], jpg["id"]]}, token=A) + expect(st, 201, "message with empty text + 2 attachments") + r.check(msg and msg["attachment_ids"] == [png["id"], jpg["id"]] and msg["text"] == "", + "attachment_ids kept in request order") + st, page, _ = api.call("GET", mpath, token=B) + got = [m for m in (page or {}).get("items", []) if m["id"] == (msg or {}).get("id")] + r.check(len(got) == 1 and got[0]["attachment_ids"] == [png["id"], jpg["id"]], "history shows attachment_ids") + st, plain, _ = api.call("POST", mpath, {"text": "просто текст"}, token=B) + r.check(st == 201 and plain["attachment_ids"] == [], "text-only POST (lab3) still valid, attachment_ids=[]") + st, meta, _ = api.call("GET", f"/api/v1/attachments/{png['id']}", token=B) + expect(st, 200, "member reads metadata") + st, raw, _ = api.raw("GET", f"/api/v1/attachments/{png['id']}/content?variant=thumbnail", + headers={"Authorization": "Bearer " + B}) + expect(st, 404, "thumbnail variant does not exist in lab4") + st, _, _ = api.raw("GET", f"/api/v1/attachments/{png['id']}/content?variant=bogus", + headers={"Authorization": "Bearer " + B}) + expect(st, 400, "unknown variant name") + + print("== доступ ==") + for suffix in ("", "/content"): + st, _, _ = api.raw("GET", f"/api/v1/attachments/{png['id']}{suffix}", headers={"Authorization": "Bearer " + E}) + expect(st, 404, f"outsider GET attachment{suffix or ' metadata'}") + st, _, _ = api.raw("GET", f"/api/v1/attachments/{uuid.uuid4()}{suffix}", headers={"Authorization": "Bearer " + A}) + expect(st, 404, f"unknown attachment{suffix or ' metadata'}") + st, _, _ = api.raw("GET", f"/api/v1/attachments/{png['id']}/content") + expect(st, 401, "anonymous download") + st, _, _ = api.raw("GET", "/api/v1/attachments/not-a-uuid", headers={"Authorization": "Bearer " + A}) + expect(st, 400, "attachment id is not a UUID") + st, _, _ = upload(api, E, chat["id"], SAMPLE_PNG) + expect(st, 404, "outsider uploads into foreign chat") + st, _, _ = api.raw("POST", f"/api/v1/chats/{chat['id']}/attachments?filename=a.png", SAMPLE_PNG, + {"Content-Type": "image/png"}) + expect(st, 401, "anonymous upload") + + print("== привязка к сообщению ==") + st, eve_att, _ = upload(api, E, evechat["id"], SAMPLE_PNG) + expect(st, 201, "eve uploads into her own chat") + st, other_att, _ = upload(api, A, other["id"], SAMPLE_PNG) + expect(st, 201, "alice uploads into her second chat") + st, _, _ = api.call("POST", mpath, {"text": "x", "attachment_ids": [eve_att["id"]]}, token=A) + expect(st, 404, "foreign attachment_id (eve's chat) in message") + st, _, _ = api.call("POST", mpath, {"text": "x", "attachment_ids": [other_att["id"]]}, token=A) + expect(st, 404, "attachment of ANOTHER chat of the same user") + st, _, _ = api.call("POST", mpath, {"text": "x", "attachment_ids": [str(uuid.uuid4())]}, token=A) + expect(st, 404, "unknown attachment_id") + st, _, _ = api.call("POST", mpath, {"text": "x", "attachment_ids": [png["id"], eve_att["id"]]}, token=A) + expect(st, 404, "one valid + one foreign -> whole message rejected") + st, _, _ = api.call("POST", mpath, {"text": "x", "attachment_ids": [png["id"], png["id"]]}, token=A) + expect(st, 400, "duplicate attachment_ids") + st, _, _ = api.call("POST", mpath, {"text": "x", "attachment_ids": [png["id"].upper(), png["id"]]}, token=A) + expect(st, 400, "same UUID in different case is a duplicate") + st, _, _ = api.call("POST", mpath, {"text": "x", "attachment_ids": [str(uuid.uuid4()) for _ in range(11)]}, token=A) + expect(st, 400, "more than 10 attachment_ids") + st, _, _ = api.call("POST", mpath, {"text": "x", "attachment_ids": ["nope"]}, token=A) + expect(st, 400, "attachment_id is not a UUID") + st, _, _ = api.call("POST", mpath, {"text": "x", "attachment_ids": None}, token=A) + expect(st, 400, "attachment_ids: null") + st, _, _ = api.call("POST", mpath, {"text": " ", "attachment_ids": []}, token=A) + expect(st, 400, "blank text without attachments") + st, _, _ = api.call("POST", mpath, {"attachment_ids": [png["id"]]}, token=A) + expect(st, 400, "text field is required") + st, m2, _ = api.call("POST", mpath, {"text": "ещё раз", "attachment_ids": [png["id"]]}, token=B) + expect(st, 201, "any member may reference a chat attachment again") + st, _, _ = api.call("POST", f"/api/v1/chats/{evechat['id']}/messages", + {"text": "x", "attachment_ids": [png["id"]]}, token=E) + expect(st, 404, "eve attaches alice's file to her own chat") + + print("== идемпотентность с вложениями ==") + key = uuid.uuid4().hex + st, first, _ = api.call("POST", mpath, {"text": "idem"}, token=A, headers={"Idempotency-Key": key}) + st2, again, _ = api.call("POST", mpath, {"attachment_ids": [], "text": "idem"}, token=A, + headers={"Idempotency-Key": key}) + r.check(st == st2 == 201 and first == again, "missing attachment_ids == [] (same Message)") + st, _, _ = api.call("POST", mpath, {"text": "idem", "attachment_ids": [png["id"]]}, token=A, + headers={"Idempotency-Key": key}) + expect(st, 409, "same key, different attachment_ids") + key2 = uuid.uuid4().hex + st, a1, _ = api.call("POST", mpath, {"text": "", "attachment_ids": [jpg["id"], png["id"]]}, token=A, + headers={"Idempotency-Key": key2}) + st2, a2, _ = api.call("POST", mpath, {"attachment_ids": [jpg["id"], png["id"]], "text": ""}, token=A, + headers={"Idempotency-Key": key2}) + r.check(st == st2 == 201 and a1 == a2, "replay with attachments returns the same Message") + + print("== размер ==") + base = f"/api/v1/chats/{chat['id']}/attachments?filename=big.png" + auth = {"Authorization": "Bearer " + A, "Content-Type": "image/png"} + st, _ = raw_http(args.base_url, "POST", base, {**auth, "Content-Length": str(LIMIT + 1)}) + expect(st, 413, "Content-Length = 10 MiB + 1, body never sent (limit before reading)") + st, _ = raw_http(args.base_url, "POST", base, {**auth, "Content-Length": str(50 * LIMIT)}) + expect(st, 413, "Content-Length = 500 MiB") + st, _ = raw_http(args.base_url, "POST", base, auth, chunks=(b"\0" * 65536 for _ in range(200)), chunked=True) + expect(st, 413, "chunked body > 10 MiB without Content-Length (stream cut at limit)") + big = make_png(1900, 1900, noise=True) # ≈10,8 МБ настоящего PNG + # Шлём кусками и следим за ранним ответом: сервер отвечает 413 по Content-Length, + # не дочитывая тело, и urllib получил бы обрыв соединения вместо ответа. + st, _ = raw_http(args.base_url, "POST", base, {**auth, "Content-Length": str(len(big))}, + chunks=(big[i:i + 65536] for i in range(0, len(big), 65536))) + expect(st, 413, f"real PNG of {len(big)} bytes") + fit = make_png(1860, 1870, noise=True) + if len(fit) <= LIMIT: + st, body, _ = upload(api, A, chat["id"], fit, "fits.png", timeout=120) + expect(st, 201, f"real PNG of {len(fit)} bytes (≤ 10 MiB) accepted") + if st == 201: + r.check(body["size_bytes"] == len(fit) and body["sha256"] == sha256(fit), "big file sha256/size") + st, _, _ = upload(api, A, chat["id"], b"") + expect(st, 400, "empty body") + + print("== пиксели ==") + bomb = make_png(8000, 8000, color_type=0, rows=(b"\0" * 8001) * 8000) # 64 млн пикс., ~60 КБ + st, _, _ = upload(api, A, chat["id"], bomb, "bomb.png") + expect(st, 413, f"decompression bomb 8000x8000 in {len(bomb)} bytes") + wide = make_png(40001, 1001, color_type=0, rows=(b"\0" * 40002) * 1001) # 40 040 001 пикс. + st, _, _ = upload(api, A, chat["id"], wide, "wide.png") + expect(st, 413, "40 040 001 pixels (just over the limit)") + + print("== повреждённые файлы ==") + corrupt = bytearray(SAMPLE_PNG) + corrupt[len(corrupt) // 2] ^= 0xFF + cases = [ + ("truncated PNG", SAMPLE_PNG[: len(SAMPLE_PNG) // 2], "image/png"), + ("PNG with flipped byte (CRC)", bytes(corrupt), "image/png"), + ("PNG signature only", SAMPLE_PNG[:8], "image/png"), + ("PNG header + garbage", SAMPLE_PNG[:33] + b"\xde\xad\xbe\xef" * 100, "image/png"), + ("truncated JPEG", SAMPLE_JPG[: len(SAMPLE_JPG) // 2], "image/jpeg"), + ("JPEG SOI + garbage", b"\xff\xd8\xff\xe0" + b"\x00" * 300, "image/jpeg"), + ] + for name, data, ctype in cases: + st, body, _ = upload(api, A, chat["id"], data, "x", ctype) + expect(st, 415, name) + r.check(not body or body["error"]["code"] == "unsupported_media_type", f"{name}: error code") + + print("== fuzz: случайные порчи байтов (только 201 или 415, никогда 500) ==") + import random + rnd = random.Random(2026) + fuzz_codes = [] + for data, ctype in ((SAMPLE_PNG, "image/png"), (SAMPLE_JPG, "image/jpeg")): + for _ in range(15): + d = bytearray(data) + for _ in range(rnd.randint(1, 4)): + d[rnd.randrange(8, len(d))] ^= 1 << rnd.randrange(8) + if rnd.random() < 0.3: + d = d[: rnd.randrange(16, len(d))] + st, _, _ = upload(api, A, chat["id"], bytes(d), "fuzz", ctype) + statuses.append(st) + fuzz_codes.append(st) + r.check(set(fuzz_codes) <= {201, 415}, + f"30 corrupted files -> only 201/415 (got {sorted(set(fuzz_codes), key=str)})") + + print("== подмена MIME ==") + spoof = [ + ("PNG bytes sent as image/jpeg", SAMPLE_PNG, "image/jpeg"), + ("JPEG bytes sent as image/png", SAMPLE_JPG, "image/png"), + ("text renamed to .png", b"just text, not an image\n" * 20, "image/png"), + ("GIF sent as image/png", b"GIF89a\x01\x00\x01\x00\x80\x00\x00" + b"\x00" * 40, "image/png"), + ("HTML sent as image/jpeg", b"", "image/jpeg"), + ("PNG with Content-Type image/gif", SAMPLE_PNG, "image/gif"), + ("PNG with Content-Type application/octet-stream", SAMPLE_PNG, "application/octet-stream"), + ("PNG with Content-Type text/html", SAMPLE_PNG, "text/html"), + ] + for name, data, ctype in spoof: + st, _, _ = upload(api, A, chat["id"], data, "evil.png", ctype) + expect(st, 415, name) + + print("== опасные filename ==") + bad_names = ["../../etc/passwd", "dir/a.png", "C:\\Windows\\a.png", "a\x00.png", "a\nb.png", + "tab\t.png", "\x1b[31mred.png", "photo\u202egnp.exe", "..", ".", " ", "x" * 256] + for name in bad_names: + st, _, _ = upload(api, A, chat["id"], SAMPLE_PNG, name) + expect(st, 400, f"filename {name[:20]!r}") + st, _, _ = api.raw("POST", f"/api/v1/chats/{chat['id']}/attachments", SAMPLE_PNG, + {"Authorization": "Bearer " + A, "Content-Type": "image/png"}) + expect(st, 400, "filename missing") + st, ok, _ = upload(api, A, chat["id"], SAMPLE_PNG, "x" * 255) + expect(st, 201, "filename of exactly 255 chars") + st, ok, _ = upload(api, A, chat["id"], SAMPLE_PNG, "отчёт (финал) v2 — 100%.png") + expect(st, 201, "filename with spaces, Unicode and punctuation") + st, _, _ = api.raw("POST", f"/api/v1/chats/{chat['id']}/attachments?filename={quote('a.png')}", SAMPLE_PNG, + {"Authorization": "Bearer " + A, "Content-Type": "image/png; charset=binary"}) + expect(st, 201, "media type parameters are ignored") + + r.check(500 not in statuses and all(s is not None for s in statuses), + f"no 500 and no dropped connection among {len(statuses)} checked responses") + r.finish() + + +if __name__ == "__main__": + main() diff --git a/student-tests/collect_evidence.py b/student-tests/collect_evidence.py new file mode 100644 index 00000000..af4ee19d --- /dev/null +++ b/student-tests/collect_evidence.py @@ -0,0 +1,142 @@ +#!/usr/bin/env python3 +""" +Прогон ВСЕХ проверок lab4 с сохранением вывода в evidence/ (Windows/macOS/Linux). +Стенд должен быть запущен: docker compose --env-file .env up -d --build + + python student-tests/collect_evidence.py --base-url http://localhost:8080 + python student-tests/collect_evidence.py --only smoke,attachments # выборочно + +Каждый шаг пишет evidence/<имя>.txt (команда, время, stdout/stderr, код выхода). +Ошибка одного шага не останавливает остальные; в конце — сводка PASS/FAIL. +Hook-и: на Windows scripts/*.cmd, иначе scripts/*.sh. Секреты не печатаются. +""" +import argparse +import datetime as dt +import hashlib +import os +import socket +import subprocess +import sys +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +EVIDENCE = ROOT / "evidence" +PY = sys.executable +WIN = os.name == "nt" +COMPOSE = ["docker", "compose", "--env-file", ".env"] +SAMPLE_SHA = hashlib.sha256((ROOT / "tests/fixtures/sample.png").read_bytes()).hexdigest() + + +def hook(name: str) -> str: + return str(ROOT / "scripts" / (name + (".cmd" if WIN else ".sh"))) + + +# Публичные tests/ читают JSON без явной кодировки: на Windows (cp1251) это падает. +# UTF-8 mode Python для всех дочерних процессов, сами тесты не меняем. +ENV = {**os.environ, "PYTHONUTF8": "1", "PYTHONIOENCODING": "utf-8"} + + +def run(cmd: list[str], log, timeout: int = 900) -> int: + log.write(f"\n$ {' '.join(cmd)}\n") + log.flush() + try: + p = subprocess.run(cmd, cwd=ROOT, env=ENV, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + text=True, encoding="utf-8", errors="replace", timeout=timeout) + except subprocess.TimeoutExpired: + log.write("TIMEOUT\n") + return 124 + log.write(p.stdout) + log.write(f"[exit {p.returncode}]\n") + return p.returncode + + +def ports_closed(log) -> int: + """MinIO (9000 API, 9001 консоль) не опубликован на хосте.""" + bad = 0 + for port in (9000, 9001): + s = socket.socket() + s.settimeout(1) + try: + s.connect(("127.0.0.1", port)) + log.write(f"127.0.0.1:{port} OPEN <- не должно быть\n") + bad += 1 + except OSError as exc: + log.write(f"127.0.0.1:{port} closed ({type(exc).__name__}) ok\n") + finally: + s.close() + return bad + + +def steps(base: str): + t = ["--base-url", base] + yield "check", [[PY, "scripts/check_contract.py"]] + yield "stand", [COMPOSE + ["ps"], COMPOSE + ["config", "--images"], + COMPOSE + ["exec", "-T", "api", "python", "-m", "app.migrate"]] + yield "smoke", [[PY, "tests/smoke.py", *t]] + yield "student-tests", [[PY, "student-tests/run.py", *t], [PY, "student-tests/idempotency.py", *t]] + yield "attachments", [[PY, "student-tests/attachments.py", *t]] + yield "s3-bootstrap", [COMPOSE + ["run", "--rm", "s3-init"], COMPOSE + ["run", "--rm", "s3-init"]] + yield "s3-private", [COMPOSE + ["exec", "-T", "api", "python", "-m", "app.tools", "private-check"], + "PORTS"] + yield "no-local-file", [COMPOSE + ["exec", "-T", "--index", str(i), "api", "python", "-m", "app.tools", + "find-local", SAMPLE_SHA] for i in (1, 2)] + [ + ["docker", "inspect", "-f", "{{.Name}} mounts={{json .Mounts}}"] + "API_IDS".split()] + yield "orphans", [COMPOSE + ["--profile", "fault", "up", "-d", "api-fault"], "SLEEP", + [PY, "student-tests/orphans.py", *t, "--fault-url", "http://localhost:8082"], + COMPOSE + ["--profile", "fault", "stop", "api-fault"]] + yield "s3-outage", [[PY, "student-tests/s3_outage.py", *t]] + yield "upload-memory", [[PY, "student-tests/upload_memory.py", *t, "--concurrency", "10", + "--output", "evidence/upload-memory-10.json"], + [PY, "student-tests/upload_memory.py", *t, "--concurrency", "20", + "--output", "evidence/upload-memory-20.json"]] + yield "persistence", [COMPOSE + ["ps"], [PY, "tests/resilience.py", "--mode", "persistence", + "--action-script", hook("restart"), *t], COMPOSE + ["ps"]] + yield "failover", [[PY, "tests/resilience.py", "--mode", "failover", "--action-script", hook("stop-one"), *t], + [hook("restore-api")], "SLEEP", + [PY, "tests/resilience.py", "--mode", "failover", "--action-script", hook("stop-one"), *t], + [hook("restore-api")]] + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + ap.add_argument("--only", default="") + args = ap.parse_args() + only = {x.strip() for x in args.only.split(",") if x.strip()} + EVIDENCE.mkdir(exist_ok=True) + commit = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=ROOT, capture_output=True, + text=True).stdout.strip() or "no-git" + summary = [] + for name, cmds in steps(args.base_url): + if only and name not in only: + continue + path = EVIDENCE / f"{name}.txt" + print(f"== {name} -> {path.relative_to(ROOT)}") + with open(path, "w", encoding="utf-8") as log: + log.write(f"# {name}\n# date: {dt.datetime.now().isoformat(timespec='seconds')} commit: {commit}\n") + failed = 0 + for cmd in cmds: + if cmd == "SLEEP": + time.sleep(8) + continue + if cmd == "PORTS": + failed += ports_closed(log) + continue + if "API_IDS" in cmd: + ids = subprocess.run(COMPOSE + ["ps", "-q", "api"], cwd=ROOT, capture_output=True, + text=True).stdout.split() + cmd = [c for c in cmd if c != "API_IDS"] + ids + code = run(cmd, log) + failed += 1 if code else 0 + status = "PASS" if not failed else f"FAIL ({failed})" + summary.append((name, status)) + print(" ", status) + print("\nSummary:") + for name, status in summary: + print(f" {name:15} {status}") + sys.exit(0 if all(s == "PASS" for _, s in summary) else 1) + + +if __name__ == "__main__": + main() diff --git a/student-tests/common.py b/student-tests/common.py new file mode 100644 index 00000000..69d15d99 --- /dev/null +++ b/student-tests/common.py @@ -0,0 +1,202 @@ +from __future__ import annotations +"""Общий HTTP-клиент для собственных тестов (только стандартная библиотека).""" +import base64 +import json +import urllib.error +import urllib.request +import uuid + +PASSWORD = "Test-password-" + uuid.uuid4().hex[:8] + + +class Api: + def __init__(self, base: str): + self.base = base.rstrip("/") + + def raw(self, method, path, data=None, headers=None, timeout=10): + req = urllib.request.Request(self.base + path, data=data, headers=headers or {}, method=method) + try: + with urllib.request.urlopen(req, timeout=timeout) as r: + return r.status, r.read(), r.headers + except urllib.error.HTTPError as e: + return e.code, e.read(), e.headers + + def call(self, method, path, body=None, token=None, headers=None, timeout=10): + h = dict(headers or {}) + data = None + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode() + h["Content-Type"] = "application/json" + if token: + h["Authorization"] = "Bearer " + token + # С lab3 POST сообщения требует Idempotency-Key; если тест не задал свой — новый ключ. + if method == "POST" and path.split("?")[0].endswith("/messages"): + h.setdefault("Idempotency-Key", uuid.uuid4().hex) + st, raw, rh = self.raw(method, path, data, h, timeout=timeout) + try: + return st, json.loads(raw or b"null"), rh + except ValueError: + return st, None, rh + + def register(self, prefix: str, password: str = PASSWORD) -> dict: + name = (prefix + "_" + uuid.uuid4().hex[:10])[:32] + st, user, _ = self.call("POST", "/api/v1/users", + {"username": name, "display_name": prefix, "password": password}) + assert st == 201, f"register {name}: {st} {user}" + user["password"] = password + return user + + def login(self, username: str, password: str): + cred = base64.b64encode(f"{username}:{password}".encode()).decode() + st, body, rh = self.call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}) + return st, body, rh + + def new_user(self, prefix: str) -> dict: + user = self.register(prefix) + st, sess, _ = self.login(user["username"], user["password"]) + assert st == 201, f"login: {st}" + user["token"] = sess["token"] + return user + + +class Report: + def __init__(self): + self.passed = self.failed = 0 + + def check(self, cond, name): + if cond: + self.passed += 1 + print(f" ok - {name}") + else: + self.failed += 1 + print(f" FAIL - {name}") + + def finish(self): + print(f"\n{self.passed} passed, {self.failed} failed") + raise SystemExit(1 if self.failed else 0) + + +# ---------------------------------------------------------------- lab4: файлы +import hashlib +import os +import re +import select +import socket +import struct +import subprocess +import zlib +from pathlib import Path +from urllib.parse import urlparse + +ROOT = Path(__file__).resolve().parent.parent +FIXTURES = Path(__file__).resolve().parent / "fixtures" +SAMPLE_PNG = (ROOT / "tests" / "fixtures" / "sample.png").read_bytes() +SAMPLE_JPG = (FIXTURES / "sample.jpg").read_bytes() +COMPOSE = ["docker", "compose", "--env-file", ".env"] + + +def sha256(data: bytes) -> str: + return hashlib.sha256(data).hexdigest() + + +def make_png(width: int, height: int, *, noise: bool = False, color_type: int = 2, + rows: bytes | None = None) -> bytes: + """Синтетический PNG только средствами stdlib. + noise=True — случайные пиксели (почти не сжимаются: так получаем файл нужного размера). + rows — готовые распакованные данные (для «бомб» и битых файлов).""" + channels = {0: 1, 2: 3, 6: 4}[color_type] + if rows is None: + line = width * channels + rows = b"".join(b"\x00" + (os.urandom(line) if noise else bytes(line)) for _ in range(height)) + + def chunk(kind: bytes, data: bytes) -> bytes: + return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF) + + ihdr = struct.pack(">IIBBBBB", width, height, 8, color_type, 0, 0, 0) + return (b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr) + + chunk(b"IDAT", zlib.compress(rows, 1 if noise else 9)) + chunk(b"IEND", b"")) + + +def upload(api, token: str, chat_id: str, data: bytes, filename: str = "image.png", + content_type: str = "image/png", headers: dict | None = None, timeout: int = 60): + from urllib.parse import quote + h = {"Authorization": "Bearer " + token, "Content-Type": content_type, **(headers or {})} + path = f"/api/v1/chats/{chat_id}/attachments?filename={quote(filename, safe='')}" + st, raw, rh = api.raw("POST", path, data, h, timeout=timeout) + try: + body = json.loads(raw or b"null") + except ValueError: + body = None + return st, body, rh + + +def raw_http(base: str, method: str, path: str, headers: dict, chunks=(), chunked: bool = False, + close_after_send: bool = False, timeout: float = 30): + """HTTP/1.1 «руками» через сокет — для сценариев, которые urllib не умеет: + заявить Content-Length и не прислать тело, прислать chunked больше лимита, + оборвать загрузку на середине. Пока шлём тело, следим, не ответил ли сервер + раньше (413 до конца тела) — тогда прекращаем отправку и читаем ответ. + Возвращает (status | None, body_bytes).""" + u = urlparse(base) + sock = socket.create_connection((u.hostname, u.port or 80), timeout=timeout) + try: + lines = [f"{method} {path} HTTP/1.1", f"Host: {u.hostname}:{u.port or 80}", "Connection: close"] + lines += [f"{k}: {v}" for k, v in headers.items()] + if chunked: + lines.append("Transfer-Encoding: chunked") + sock.sendall(("\r\n".join(lines) + "\r\n\r\n").encode("latin-1")) + for part in chunks: + ready, _, _ = select.select([sock], [], [], 0) + if ready: + break # сервер уже ответил — дальше не шлём + try: + sock.sendall(f"{len(part):x}\r\n".encode() + part + b"\r\n" if chunked else part) + except (BrokenPipeError, ConnectionResetError): + break + else: + if chunked and not close_after_send: + try: + sock.sendall(b"0\r\n\r\n") + except OSError: + pass + if close_after_send: + return None, b"" # обрыв загрузки: ответ не ждём + data = b"" + try: + while True: + piece = sock.recv(65536) + if not piece: + break + data += piece + except (ConnectionResetError, socket.timeout): + pass + finally: + sock.close() + m = re.match(rb"HTTP/1\.[01] (\d{3})", data) + return (int(m.group(1)) if m else None), data.split(b"\r\n\r\n", 1)[-1] + + +def compose(*args: str, check: bool = True) -> str: + out = subprocess.run(COMPOSE + list(args), cwd=ROOT, capture_output=True, text=True) + if check and out.returncode != 0: + raise RuntimeError(f"docker compose {' '.join(args)} failed: {out.stderr.strip()[-300:]}") + return out.stdout + + +def tool(*args: str) -> dict: + """python -m app.tools … внутри контейнера api → последняя строка JSON.""" + out = compose("exec", "-T", "api", "python", "-m", "app.tools", *args) + return json.loads(out.strip().splitlines()[-1]) + + +def janitor(*args: str, attempts: int = 10) -> dict: + """Один проход очистки внутри api. Если advisory lock занят фоновым + проходом другой реплики — повторяем.""" + import time + for _ in range(attempts): + out = compose("exec", "-T", "api", "python", "-m", "app.janitor", "--once", *args) + stats = json.loads(out.strip().splitlines()[-1]) + if stats.get("locked"): + return stats + time.sleep(1) + raise RuntimeError("janitor lock is busy") diff --git a/student-tests/expiry.py b/student-tests/expiry.py new file mode 100644 index 00000000..503cf37c --- /dev/null +++ b/student-tests/expiry.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +""" +Истечение сессии при коротком SESSION_TTL_SECONDS (=2). +Запускается против отдельного экземпляра API с коротким TTL: + docker compose --env-file .env --profile ttl up -d api-ttl + python student-tests/expiry.py --base-url http://localhost:8081 +""" +import argparse +import time +from datetime import datetime, timezone + +from common import Api, Report + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8081") + ap.add_argument("--ttl", type=float, default=2) + args = ap.parse_args() + api, r = Api(args.base_url), Report() + # Экземпляр с коротким TTL мог только что стартовать: ждём готовности до 60 с. + deadline = time.time() + 60 + while True: + try: + if api.raw("GET", "/health/ready", timeout=2)[0] == 200: + break + except OSError: + pass + if time.time() > deadline: + raise SystemExit("API is not ready at " + args.base_url) + time.sleep(1) + + user = api.register("ttl") + st, sess, _ = api.login(user["username"], user["password"]) + r.check(st == 201, "login -> 201") + exp = datetime.fromisoformat(sess["expires_at"].replace("Z", "+00:00")) + left = (exp - datetime.now(timezone.utc)).total_seconds() + r.check(0 < left <= args.ttl + 1, f"expires_at is about {args.ttl}s ahead (got {left:.2f}s)") + st, _, _ = api.call("GET", "/api/v1/users/me", token=sess["token"]) + r.check(st == 200, "token works before expiry") # заодно кладёт сессию в кэш Redis + time.sleep(args.ttl + 1.5) + st, _, rh = api.call("GET", "/api/v1/users/me", token=sess["token"]) + r.check(st == 401 and rh.get("WWW-Authenticate", "").startswith("Bearer"), + "expired token -> 401 (cache does not extend the session)") + r.finish() + + +if __name__ == "__main__": + main() diff --git a/student-tests/explain.sql b/student-tests/explain.sql new file mode 100644 index 00000000..235f1f9a --- /dev/null +++ b/student-tests/explain.sql @@ -0,0 +1,60 @@ +-- План запроса истории на ≥10 000 сообщениях (уровень «4»). +-- Всё внутри транзакции с ROLLBACK: учебные данные не остаются в базе. +-- Запуск (одинаково в PowerShell и sh): +-- docker compose cp student-tests/explain.sql postgres:/tmp/explain.sql +-- docker compose exec postgres psql -U messenger -d messenger -f /tmp/explain.sql +BEGIN; + +INSERT INTO users (id, username, display_name, password_hash, created_at) +VALUES ('00000000-0000-4000-8000-000000000001', 'explain_seed', 'Seed', 'x', now()); + +-- Чат, историю которого читаем, и 9 «соседних» чатов, чтобы в таблице были чужие сообщения. +INSERT INTO chats (id, title, created_by, created_at) +SELECT ('00000000-0000-4000-8000-0000000001' || lpad(g::text, 2, '0'))::uuid, 'seed ' || g, + '00000000-0000-4000-8000-000000000001', now() +FROM generate_series(0, 9) g; + +INSERT INTO chat_members (chat_id, user_id, position) +SELECT ('00000000-0000-4000-8000-0000000001' || lpad(g::text, 2, '0'))::uuid, + '00000000-0000-4000-8000-000000000001', 0 +FROM generate_series(0, 9) g; + +-- 12 000 сообщений в целевом чате + 48 000 в соседних = 60 000 строк. +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), + ('00000000-0000-4000-8000-0000000001' || lpad((CASE WHEN g <= 12000 THEN 0 ELSE g % 9 + 1 END)::text, 2, '0'))::uuid, + '00000000-0000-4000-8000-000000000001', + 'msg ' || g, + now() - interval '1 day' + g * interval '1 millisecond' +FROM generate_series(1, 60000) g; + +ANALYZE messages; + +SELECT count(*) AS messages_in_target_chat +FROM messages WHERE chat_id = '00000000-0000-4000-8000-000000000100'; + +\echo '=== 1. Первая страница (limit 50 + 1) ===' +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = '00000000-0000-4000-8000-000000000100' +ORDER BY created_at, id LIMIT 51; + +\echo '=== 2. Страница из середины истории (keyset-курсор после ~6000-го сообщения) ===' +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = '00000000-0000-4000-8000-000000000100' + AND (created_at, id) > (now() - interval '1 day' + 6000 * interval '1 millisecond', + '00000000-0000-0000-0000-000000000000') +ORDER BY created_at, id LIMIT 51; + +\echo '=== 3. Для сравнения: та же страница, если запретить индекс ===' +SET LOCAL enable_indexscan = off; +SET LOCAL enable_bitmapscan = off; +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = '00000000-0000-4000-8000-000000000100' + AND (created_at, id) > (now() - interval '1 day' + 6000 * interval '1 millisecond', + '00000000-0000-0000-0000-000000000000') +ORDER BY created_at, id LIMIT 51; + +ROLLBACK; diff --git a/student-tests/failover_each.py b/student-tests/failover_each.py new file mode 100644 index 00000000..2bd2894c --- /dev/null +++ b/student-tests/failover_each.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python3 +""" +Поочерёдная остановка КАЖДОЙ реплики API под нагрузкой (lab3, уровень «4»). + +Для каждой реплики: дождаться, что LB обслуживает все реплики → запустить +нагрузку записи → через --before секунд остановить реплику (docker stop, SIGTERM) +→ ещё --after секунд нагрузки → собрать RPS, ошибки, время восстановления → +проверить сохранность и отсутствие дублей → вернуть реплику и дождаться, +что LB снова её обслуживает. + + python student-tests/failover_each.py --base-url http://localhost:8080 --output evidence/failover-each.json +""" +import argparse +import json +import shlex +import subprocess +import time + +from common import Api, Report +from loadgen import LoadGen + +COMPOSE = "docker compose --env-file .env" + + +def run(cmd: str, **fmt) -> str: + out = subprocess.run(shlex.split(cmd.format(**fmt)), check=True, capture_output=True, text=True) + return out.stdout + + +def served_instances(api: Api, n: int = 30) -> set: + seen = set() + for _ in range(n): + try: + st, _, rh = api.call("GET", "/health/live", timeout=2) + if st == 200: + seen.add(rh.get("X-Instance-Id", "")) + except OSError: + pass + return seen + + +def wait_served(api: Api, iid: str, seconds: float = 60) -> float: + start = time.monotonic() + while time.monotonic() - start < seconds: + if iid in served_instances(api, 10): + return round(time.monotonic() - start, 2) + time.sleep(0.5) + return -1 + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + ap.add_argument("--workers", type=int, default=4) + ap.add_argument("--before", type=float, default=4, help="секунд нагрузки до остановки") + ap.add_argument("--after", type=float, default=12, help="секунд нагрузки после остановки") + ap.add_argument("--list-cmd", default=f"{COMPOSE} ps -q api") + ap.add_argument("--stop-cmd", default="docker stop -t 8 {id}") + ap.add_argument("--start-cmd", default="docker start {id}") + ap.add_argument("--output", default=None) + args = ap.parse_args() + api, r = Api(args.base_url), Report() + + replicas = [line.strip() for line in run(args.list_cmd).splitlines() if line.strip()] + r.check(len(replicas) >= 2, f"at least 2 API replicas running ({len(replicas)})") + results = [] + user = api.new_user("failover") + for cid in replicas: + iid = cid[:12] # X-Instance-Id = hostname контейнера = короткий ID + print(f"== реплика {iid} ==") + r.check(wait_served(api, iid) >= 0, f"LB serves {iid} before the test") + st, chat, _ = api.call("POST", "/api/v1/chats", {"title": f"failover {iid}", "member_ids": [user["id"]]}, + token=user["token"]) + gen = LoadGen(api, user["token"], chat["id"], workers=args.workers) + gen.start() + time.sleep(args.before) + t_stop = time.monotonic() + run(args.stop_cmd, id=cid) + stop_cmd_seconds = round(time.monotonic() - t_stop, 2) + time.sleep(args.after) + gen.stop() + rel = t_stop - gen.t0 + later = gen.instances_after(t_stop + 3) + res = { + "stopped_instance": iid, + "stop_command_seconds": stop_cmd_seconds, + "before": gen.window(0, rel), + "first_10s_after_stop": gen.window(rel, rel + 10), + "first_success_after_stop_s": gen.first_success_after(t_stop), + "max_gap_without_success_after_stop_s": gen.max_gap_after(t_stop), + "stopped_instance_served_after_3s": later.count(iid), + "instances_after_stop": sorted(set(later)), + **gen.verify(), + } + t_start = time.monotonic() + run(args.start_cmd, id=cid) + res["rejoin_seconds"] = wait_served(api, iid) + res["rejoin_including_start_s"] = round(time.monotonic() - t_start, 2) + results.append(res) + print(json.dumps(res, ensure_ascii=False, indent=2)) + r.check(res["max_gap_without_success_after_stop_s"] <= 10, f"writes resumed within 10 s after stopping {iid}") + r.check(res["stopped_instance_served_after_3s"] == 0, f"stopped {iid} not served after detection") + r.check(res["lost_or_changed"] == 0, "confirmed messages preserved") + r.check(res["duplicate_texts"] == 0, "no duplicates despite retries with the same key") + r.check(res["rejoin_seconds"] >= 0, f"{iid} rejoined the LB after restart") + if args.output: + with open(args.output, "w", encoding="utf-8") as f: + json.dump({"workload": f"{args.workers} closed-loop writers, retry same key on failure, " + f"{args.before}s before + {args.after}s after stop", + "replicas": results}, f, ensure_ascii=False, indent=2) + r.finish() + + +if __name__ == "__main__": + main() diff --git a/student-tests/fixtures/README.md b/student-tests/fixtures/README.md new file mode 100644 index 00000000..12ad8e3f --- /dev/null +++ b/student-tests/fixtures/README.md @@ -0,0 +1,7 @@ +# Собственные fixtures + +- `sample.jpg` — синтетический JPEG 240×160 (линии и рамка), создан программно, без EXIF и персональных данных. + +Остальные файлы для негативных тестов (oversized, битые, «бомба» по пикселям, +подмена MIME, шум ~9,5 МБ для эксперимента памяти) генерируются тестами +на лету (`student-tests/common.py: make_png`) — большие файлы в Git не храним. diff --git a/student-tests/fixtures/sample.jpg b/student-tests/fixtures/sample.jpg new file mode 100644 index 0000000000000000000000000000000000000000..98387ecd269841df4d62bd6e67be336215e4bb22 GIT binary patch literal 13406 zcmcI~byOT*lx9KW?rsSk+^um*f`tG95+qm%7Tlq6f`{N5oZ#*b!QGwU&{%*FXb8|) zv;1auXV2`+Sv~ve-1_HL)p_5!b^Uwz`LGEPy;4wC08mf>0Oj!l9#()C00tU5209uB z208{NCI%J`5e^PEHVzp9As!JW85I>J83hFm{WC@yT4p*53MMWlW)@a<4t8orZa!`{ zzGrOgZ2x=&1rrk!2MdQ32Zxl6hJuFe|9Cxg0mN894sZ%Wc?zHsqkxD}9{K>r$8(~i z{L2FV>q0>VJ)Rd63mXUb@qq>+02KuULPZ0iqobicKJELs51sTv2h`ImC^#fEEc{DEd_rPUa>}>VwA{S>g2JNWlG56``i91) z=9bo;-oE~U!J*-inc2Ddg~gvs%UiJRo!!0tUk8Wqv-7_fmsg1En}2Yj0HA+`^?3hR zVE+Ry;zwMlXlNib%ztp9pn5zCh!_q12|osjoCc1hCo|1ob zp2nd73vE4v{{!t`kp1rg3;e%A_HV%cJFaB_4}|ilJPPAmuBq)Sz~2Qv0J$rwP7SZW5hj9? zfinDqP%89L)QHQGt#*&o?bq;^+i#kZ{{HZ!5m8mZ`*Tf5n@EH`s4!#_vJWCZni?E% zR_ln@SN1<1Exq$q!}+FzHqZSLIeO2iKC~mry?y`UWouZEF^Sz?edhMh)&%wXM3dn4 zL;rOK>n1e3%~0#nw%SEM(rfXiFy78aNoKdFqg-aFIS|}r>VdbFU;|Xyp@AvAQtR`B zss63(NO9w3?leL2=mz^-Wu1LsxU*!FT@lH z3CG)NOsWrZo8MQVct07!YL#zGyjQB~WKKI`hIZcx&HoU;FTSZP8#|CRDbl-BpXR!l z#5{}^&Xjr?r+A={r@;frd*Jg+JAfkRJ{y0*LyZ z0^7XKv9J$ki@ABch}W=;EQTH=Bdah$tmz^9U`6InTJWmxF#UIvmwZ3vz(25HV&gR!73C0-dVwM;N7#=M`O zHX~+ee_I z`BWy7*N47>vz*e!Gufs2t+p)@?Wz*FEVZaPZe&6zV(?WP!VXps*9o=NsJB`iX>Ve5 z!-a5&UX#TZC=KE9PlZSrlMAIgkU_Oq`u!MM*W8K*?4M+zk_{6vHR^|Izor0*q45o< z(;X72jc#UdJ^)o+OOQoZT|}LYNSt>*bXHAuk;Wj9GjWK)3{Po5O?EdGs_E~Uy;XUB zPiQdhzu%GV?|_`SjuS_snK7CgEC#sUs?$MvM}N4c?ey5WVZAV^mD3yqK8OxeZJGr* z7uHD=tPfjS`fo`oYf339rapSvy}mJh=p@*lH3Ov~VWFjn+F5iI7Pk8Updc+uE+{w4 z&-8yS7Y2EVtGMMGE2F&CYIu_nNrx8*)0&h~oOS$Jjc==) z@L$}gLNc_UR`;`pAw|eTA-5Er))UX!qlJ^mlBJ_Jp0Ivr@Yp+vCTOIw2r2KUkvfjf zjly?Y%#NI3sEO7jN%3{6ze?4*i!pFgllb zlY|#mJ|PWPnix~PoDvBqFZ#{yWZdTbo;kdi^&=u0uPjlYbzr@SMrIju}=WegL# z7e&KIlU1(y${u^RLpp&=;?FQYfPf%5I_a#X+5Bv6>&%O8;iK+SR2h6SM^4$v4M?^l z#-$F*v>CMXss^s5ZYbpB=L@X^oCpdFOONk^zo+65+%2VmMME&Wt$qP0hE)kqx&o0x$Ij)|AI+*Yi57v-HF@} z*|4r%-s7u>wilCe+)?NL0vFkZ=SrE`91(-l0FT9T}-#q}q5W?>X^?=jo0MX%7za*B(Swz)azdbetO!0%Cqn++J*E&pt4EICt1Pc*f z_{l_jTA7O^fcXcd%|=W*0t`%s_PN0{f5Hvqi@u3udbat9*-t!KF22TbUpHg0CJQH8 zJL)`Lq-!|HW2wJ#1Y(fK=r9rNGXw?L)aOR5^J{1;ehu$aCzke#F&-U8C)0TQL2JH# zMao#Uxq7Z*1~%cg1XiDl*~1cLik1VSZH5}ML5Q#2q=rTa@&}+nNIwR0OhY~;pg1YaMyH-{+54 z#i+bU?(h3u^!W^GLB7c5&Z|7?r6y)8Cf=b2Geyg7RR!45bBHuOA`B-bZQ6J!;!u9| z+1Z2#IM`W^xx?jL^umGuPIOjMLv)UN*O%8wAu2&5NTTD#z%Cl9({wGBiDy?ov?%g- zWd-;avyYay?y!QUAo&M|86^r;)yb)!+p>Z#Z`yY)j-`HI0-7I^I;U#|S8eXdJO4A& zkuo(`Y2l)+2Vl9gYu#5-6_HRRpASt+P==3}`KGPIbVs;H@sNLB6DIBuz1_xhZdui= zwDPLDdnO`)0KrIA%_~-h&@+FB?Fj@t58KD0+35UtH%z;B+PDRmVRhm27N^&m!B#>F=W3eA+AuY&Fw0 z(*G&G83;y_A|kSvTJI|f(o2m7embPv(+{3z5brtX;}1TQv(fendjzcoWgT?7Pw!hu zRTa5$Umh^D~Kt3 z(?*Hj@S_T^77WSLQH}cKSzYS`I~lHw#18;01>O{Pr{i#&?wNl}k^2Dj40%z!yZ&~( z?j5sMLDjkEA_k%S2k1q7|ybU4zRDamxC=jEnBQ`yB$a0`7yl`Xfm-%nUV7I43MQj4MFzvdendZrs= zK*A~0&9dF+kKbU7e~9gHUs6=wY6>ndCr|vy@*yvvC_us46ii~Zj{2h+&f0y{CYrSS zBXq%6>;?LpG3NW9n1v#>cp1(FzUrJ`19cuVBn!B=puLq@_7>^5WDL0WllKhUdL zrMQyXHd);OT)`pWCSI0duP(zj!)Kh^%|Sr@Gh@f;dVvS;q=)eBbsdD4btr7lz9`vr zvgD!w;q(BIPEsM#`?kL^sMoBBJ5~nKCCTtfXfv;zFi6qotgCNj2i6!4Rgw4TOZ2?u zj5UwFRt*}Eb^|l4wY~K+pM^p;cPKUPGkFWYjzuK~7%8i1v@i;C5Gi$U@lRRgdNm>y z7Mz_MkAKFGB02mcu3S`Zk0s<{M#KHFGESW7HZ7U^T@0Y-gHBNQvEx~x z16+e<=Yne4xM~G~{6r%{aKdCm$RYgC$^zoYz1$LJela+ zO10x50X|Rc@Z%le+I2ONtS*wTT6}@P@a9I^L#~}vUiQ|fJWuMsh@I1 za!*#zM5YJzN``-#KOrNFuaH)!_LNI&-I}L0ERw~rhviv+<6TCbhy8v=Mu6zEXum9b zA#M%3`d^EhaJN~3QBJ?p_jRBotqh@z_=(5r#O0jEFM8&n=}#J#p+jGS;B`|(1=xKv zKL5L|{YNDhg=HfmT4m}?iy_~-rXW!PT_#L&FC@8wHFgN0tq{xbgi9FdGrrZcN;2$aVYD~8* zJ7}VyNoqCFn`i@nxgoym#zZ3?Vj>MEr7$F z9XdGFaB1$-aBFtZ=zfzD>af|Qbi%W+%bElgKs#&PuVLb+K8hp=FkR{0*9@k!QB1x1 z(eVJtNZqcUmzocc{9Q}gxbjaPFpMs-yian;JM6TY^N}L8ukQ$@Q#BPV`2c*xptT~T zIL*>RH?JWHgp%o*ilmj446X3YcDm_Bl2JK4CqkscIJ zqLS8oJMSsDt~!^+61ZTa@6iZHMvVT@mpF+hzG|$ND0-g9;mHJ9-_l;FDxZWd`}Y~* zt+15Xk2;jT=co(c>3upRcR-tiyMhUjEHU@EPGZP=OT1tyO+FJq?&gQ1Sq}BoQCy=? zU&jF3qSPj$r;O=^zO{>*=RTD@AJ6!vcB?C{I?TjC9u}fZ=D1E1RKXVo4rxn&en`0c zJFTd>F3;#(Gpc2(tvrWUCc!GC8W9eC)8!rp0o9ZD``uXOgqkXh7xM*Mqzqwjn|>NC z=G;T;l&N7sbe`2Z4m|u`0p;18$cvqr)ZZQC1smbCuVeJD?U_AhE2YQ2^I}aV3(NrN zBT0v^I!6@b`l|0(oBZ(((pC^rBn#dr)oUfS9~Ua-_^vylB0hsuhnSMvlNlWECuqwY zuKcvcVY5H4vQhkV5SW9lbgOFz4}jIVp{K%_ytLM0x#}DN)*Vwzd-UR^Pi?5Y^P&sY zn_?ziP?JIvY=}DM6(Sgiq>>uQCwap3Sx9+)nuE?rqHt)uOvzKdWtPkC} zog^pZ@{ddtD^%n@=3ZgxrRVJf05P~M&)-=)Zc{%M|G0Ky-y|Ib?=QTU>6Rw==2_R) z!$Y%lHWZhm@BwQA%koM1w#jxS_tDuPtcp>-Xz1WR2fe?@aggz+46g z>lf?3*(tF+7ahUhcQh=OlY$4?u4h=wgo+<6b~N3_*oVEP*$=PsF)d3{<$d)b`Hgs@ zRfheiTr|r)%stbD$iFKyY;L^OtE#Y0V*P&U2G2%Sk-5`Sper?{_zi0C@Nl=xaSW+L zh!bJMSnH+jQ;%qDM1rx z-5$LhX-3F^ri!~4*}8#8-#RD+xfShQ1 ztj_$#ZbH9X&mO)%xwLmQjVf;+{Gi~h_)X+;^L&xXqgT029*OzRK;D+i^GKui0U%l2 zU2-*qct~X9L%ojrRJa?XNS3XN-|_HTVEWtz1qvwmfBm@W*!Jbg`yXMw%NW@?@9Sx7 zB_Nx_%=D8_K-8?~n;)DVF>Lnym(pJ$dl1{OOy-GmWVfZ8&EE0Ko~H*t&u_DB(Fp;Y z!{wRGXZT)O3J`&kh%5IPhjU+l+1vu%D#T+ZkoOa3>o{ixkwEtL+^~jyr zjtVx!+%`4#mPUkC{M zYQS-~lH<1VuZ-ba<@7Id6bq8fevPebO-Xz9d?Qh< zVu^I-N_PYVkDU#?h?_AU@o2I4;wp9b5?R8pgdMBa=RJ^(oGV7Egs~s|*|!qLqm{b! z$PxR{>*i(tNldUQt5jopNpJZBV5j%G`aVyuNhOIRR8jwD?N91ul*H?ASOj<@dCgUl zQHRI*XL6D*a?Jfgw)FH=Wt^Z`IeILqqioW!mS0|!ScWei|#{=JTobc&2KOd``U_?TNB6I&Ht z5}qxkSasZJx4%1i!UUU-kpH};ciObh2%P)(Qceghuho0x%&C*^n z9@mUQvM%qnf2pzGT!jkz<63Jh9ci!YztSI0qIGovoRXMNMMas2V+A-pdd1P#tNh86 zBE9$hbhF!Nt}LVi9)Kgfcy#BzhP+p+l~>Da>W?Ae7TPi@Pk%C1U}^mrI0homB+y@K z#P|ILJcJLkuo3n%!R>GoyUz*ipQy@q_D|xXnyExFCC?*?ye82R9HYI{@=gL317-Dp zvNKq`g6YF-w^>DJQ*eZkeJ^pb?(*Hqi#sYT)4?sdP;`0OGM0n2?-I11q8o~CT%fHi{v8v8kXJgpi z@W$o!15nQfIw<{bj&E$Sp$#8ryi%BYfxkX6lDOkJe@~Um(2ZpV&VIY)_NWx@Jx!my zx1R^bn+E_4HuKr>7`km|AW+(tX0Nn?q%|zH&e_v=2Y&Y;0swcw5p%YMr8?6_TGx8g z1|?Cg_MOdb^__9ib-JH0{Kud6UEPL?@HgnCN=l~PqgfET&(We?gJP`l(~?$|P)iM) zOo4sZmm){XUxn~vF#`OPNndMbPM>l?-t?Lf8Y&YWQtRa%Yc$d#{chGuQf8Agtb3(L zLY1YLX&OaVCqah}Dq*dzVuly>ec|z+_7OkR?>)!nc@=On=aV^SnsK@&ZklD>kL2lq zgNu3Gd#$KhB%s4xlAAS1mO<+6pLl7zYe(^J=2}X&zDAg=q4eIb6>5*C{l6W6|CYvg zSSxGFk&I~cz3zWEbgfJU1|32O$GjF5^AGHbRQ*d{(d#QTDrd$89k<28$T{4T*v25B zHVhU_G1S&i8XAy+kAKC)j`#FM|D^Jx)k-Q|)76G>@h=7(UC+O4NP}^vK2aUEqe|9_ z6)7=)eS0^N7xVta&NVp@HYUrxwspEYzP9qbmjfK_+;&5W?vDmwmX9z456>V$)RYM9GJ)a~T`UGHCni1QI+T!VLV$3_2o({Pi|FAe zBk_&Vq{26MJfx3a>l>V$$ipA%-Uj1ET+1z_l8!n^x~vSr)k!gT7Fe!OVi(3B@aKDy)$C)c6}Euftah$%dpVM{s#D+ z(smd{s@bgncHnlyecM{y5_-7&`gbxlDDT7OW;7vFOizav<>!jvq*88i>BvhyM4H?D z=EZNHmH%aQF|d^VCrtcj^6$J5=YdMuH*O}YKZVg)I<)z5fyKjJ!;)^o+cHFM-i)-5 zli9-5BB_w{Y{WO?fk;`=+w@Q!3FYM$cih=P4pxm9E_K*}B@roYx%y4D$Tn)P&SS{d zmW6-K-wNHeWGcv;0V0C^-4yWUAic{9=12o$gtmCpPLs!%;&CTVdk?eMkK+?xM+wsg z_XR(qsXrAbJW)|eg)SOF->w()O8$UfAFqP0l!=QPC4U*OZKHOy+f z*4FM>!(D5hL<_)vqh^Re9&QITH2V52Dxi(F?)1&XF^R3d;79wrjIoNs?4xx$woYF+TWNcd%40Dny;5R$9NxyZ`u$Dv zD1Ev5`1F^fEGf;CE+g7DxOUVQCq1bOztuEursjd|wAr^!Iuco1x|r5JLO!RncN>HV z-kzJuzBMoTDOWL}3IX9J6(>^~w!}!%YBv19+Q>$)NJ|iHS%tbt!TTy5o|FfGx6@_J z0VxD^-|jbJo0}QcCbCX5U3y-~cE$N^TFzwe1K#&v>h_!>gkRs2x%=USFI#)ptCX-b zKNUSaoaKzlmSF`h28DmE6P*@?xyfKcHw+VGXB5*fW9noVoSK&02PQ;BL>~ZMOu)Ar zq4nd`B1EQZlv`7Z^>xJMx+(KmqtkVKN$U2pG4h0vr_*8@|o59sD<HN{%!Vy_WZgE~5*l#%dLGL3Iv9QR+;ar)QJ zY<^l63q99C?hxnZU;I1;o1J)2515&I3X*ZAU`kS+Is$C-@&QoH{v0gI)dKci%kj*+ z&9G4`&^^pnM0{FYD;Z}iYT2xVj`kj39=)yayk-4%rl&SNxLQ$6B@Vkan)$DMl<|%ujOvr0^Xkwem*I}j3dS)O#>T~^2 z9-4A?rn(pi`uB-GDW#jRgIY{gk>5&261$dn-x&q`S?U9jtiyOU@&H7+`r#pJ{5Nkq zAJ=4kaQ~7dX@ifhsM$o`&yRV|WH^5eQUg$YB(Zv9iP?Ol8Mza|xy zKi1jV*T20B$c+Zh7T+|el;M7}ugISmHi;D%c`N`o&#>+|`k~`OzbEA-4g(|D@=+dJ zg#RYGMjUYAurS+ol~f9qik66ZT?c2Epy<)=>mO|ypb*#tKvEBAuf7da>sZ zNPqU2S88XvbxiAbo*CI16B`@bP<$J|6*RhIb9fiGt#Pi$g}FKX6JP zuFZaq-mry{B#sVJ~)YRWvrf$nH3?sh`F4+z}0ETm=rP*6YAxIv*XaRj;+#mi`#%EIg z4m3_zLJ_m-BT^flG7_F|MF?GT{CnhK^Jn!xp|gKSKQtaa@mLGsKP%afOX0w^{G9Uh zr)Oh4w0A&-s6Gmq{R<8_+5K;&T~g5NzE`HSyfOS8doJZd#I*vT5!o_APzu z2EYdy1>qSVOc^=1qaUq`hg6;LPD|XSm6M%)4+%C)?ui#&?g$R_h*T3#N^4DMXlhzA z9%21SpNotNnyb#gE*Mx6I0w9g6* z@1`upW1^?9hJvZ){ftC^^%5ZxhqsMsRuHDD@4^&k(y!L_ZK(`Pci5>$?)w1-WwGvU z8<^tVYhiT)#Ph)`M}r}7O9bOu(r0l~gd=LpO3(-|yvL?X!xqd%mI@mO5$9J1kJG@h2LR0!DzZ!^jcHBtGTjI^^XSEt zSG&Y5S9ay;ytI5|Z1DHH*z=lIe>Hk&evX$mi&xYd%wv-YaZn_4yrbpBv!cnw&jWv#H*tlaK%fM>r{qQf5B=a+VsMU_sgF%#`cHFS0U1SobNga3E=%% zZF4kJa|xQ|9x%VJgKqRvFmRrpU%6C=$sAL*5ULOTkYd4O?f2A2s`XYibKu|) zOw&-wGzIL&rX-Pg7Hnq9$ofuvQ6=fuWhXL@cWOUV`f>blu1H(-zOg~VCJV2o5dyC~ z){=E4BrSgOb&%G-JS3d4joQqv%|AHQO2n>2&v+GzL+P5NepwV|pHFK4MYp!zEJT29 zOU~d`B$U-rc<#`h7*UB1AM9=PmLXb(r1}>P$oV3~%o+QXCaL;@B<)uV8w#R|`lxu^ zHgME#AklV)y=awQbYf^cQuZT zuL971DT2DypaWin`f- zZ{)W+L3*PY-#S~=thONU9QCpuJA`!yI{{XbkG70eS8)0(SH zKU2-N1ei_)(`@-m_$P|jMm8Z-yo2jZr`Q9OOtH9hZlFAPWea7nkcuj6?^K^Kbq#q# zE9y8+M%1mN2MLt=urJF|{!?7yp{g>cAH0H6iT9k}$Fq3#s5R0E@3h@fh@+Gz6?2$K z>xz)-odLV(@C2DNmN{{wMnY07ZJc1TalH&4(~Z!dE+Fk#C z_oasSfp;>Y6f=h@X+>YFW^Hd0Lpj}sB%WwRntfn+%ge;LwvQ-vh*LZ0}Gn0;F z5wHJDi-!C|ch}#T5#XIcTrX4Lmgbh36_VR)Lkbpgclyv4n*#_K#(-Gk)k|2)zK@Fy z_fP1Lo*_G#!#m>|CL@zYpbCxCc4;2bW>n`?gsI{?cW?%$!2B3j#1^g5CvmlGdyOi4 zH!@ul9+242qXG5TwUK|R$yvJ*$VG?Bqj9`y=@P#`#L+q*z)?jY8Np`O`>dbBm@$tO z6>~UecbXX^*X0@Qpyk#p4Ez8^u|DpV=KV^c=mewZ%elrQomGARFSN;&yVmP(zK^WQ z(`A-g_*L|=eT1URvl#=hdACJWngSjm#dnac+Qnei!Jbr4_;sCOF7c_p^;9}`GMIM9 zw+nTNUSR4xV+-q`Tg4xdbm!S}t2lmN@j)^w<9N9&b7??kPUiIm17Zd-U+Dh{fpI)< z;c2_0lBhf264da8>KFOX%K^bDnl+jAvSV;3CyxFXxW7W$dGF~Fjnh)euXx{D$}SnU zZa?gmfvMG?D?UtNOM_WEX=Wek&!K(sF!I(WP7!VD%eaPb1hUVPnlCnq_&akq^r2sS zlT$)P&6+xz@WIc5OCfkdmNnfYSrQDKp$I#nEGoE2*=E}TT~DO_-@&+;N#dPiR%+3G zoaWVMQYCVu3F;9vcdfD0FSZ!U9AJb5Mo>tfqhyna_0W`BR07rqK4meyNJr@dkcAi~ zHS&MWcWTJ~+G=u{@?_)fxo zgy(nONWNtu*8V4Oe7UIRic=s6(zlG}#}vrO=p&T6J(p+ttiN6s(-O3I?RmdPIF=EH z$t-q#B~6Biu-a}p)%nU4%B?WK??5KV_5dgav!i1TEc9&0`k9M$cbiTeYMQun5g6t&iiu9p*-B)a_J*A^~rybqSlsT+Xwd_=Qj&ij6ROl`~ zg5_3>q+E(&l1^4Ti0DzTyzSw*a5O>ID+5z*YN}^)-9X4prtYour;Q~0jyXoR9dmKJ zk;z9+`{GznbK@eC_UCXeBD!BvZqqwi+U6<$8BwFCq~~j8g>KQcD_y#V_p^U1w4O(+ z6Z 201 (got {sorted(set(codes))})") + r.check(len(ids) == 1, f"all responses carry the same message id ({len(ids)} distinct)") + r.check(len(instances) >= 2, f"requests were served by >=2 replicas ({len(instances)})") + r.check(sum(m["text"] == text for m in history(path, alice["token"])) == 1, "exactly one message in history") + first = res[0][1] + r.check(all(x[1] == first for x in res), "every replay returns the identical Message") + + print("== семантика ключа ==") + st, _, _ = api.call("POST", path, {"text": "другой текст"}, token=alice["token"], headers={"Idempotency-Key": key}) + r.check(st == 409, f"same key, different body -> 409 (got {st})") + raw = ('{ "text" : ' + json.dumps(text, ensure_ascii=False) + ' }').encode() + st, body, _ = api.raw("POST", path, raw, {"Content-Type": "application/json", "Idempotency-Key": key, + "Authorization": "Bearer " + alice["token"]}) + r.check(st == 201 and json.loads(body)["id"] == first["id"], f"other JSON formatting = same request (got {st})") + st, other, _ = api.call("POST", path2, {"text": text}, token=alice["token"], headers={"Idempotency-Key": key}) + r.check(st == 201 and other["id"] != first["id"], "same key in another chat is independent") + st, bobs, _ = api.call("POST", path, {"text": text}, token=bob["token"], headers={"Idempotency-Key": key}) + r.check(st == 201 and bobs["id"] != first["id"] and bobs["sender_id"] == bob["id"], + "same key from another user is independent") + st, _, _ = api.raw("POST", path, json.dumps({"text": "без ключа"}).encode(), + {"Content-Type": "application/json", "Authorization": "Bearer " + alice["token"]}) + r.check(st == 400, f"missing Idempotency-Key -> 400 (got {st})") + for bad in ("has space", "x" * 129, "slash/key"): + st, _, _ = api.call("POST", path, {"text": "bad key"}, token=alice["token"], + headers={"Idempotency-Key": bad}) + r.check(st == 400, f"invalid key {bad[:12]!r}... -> 400 (got {st})") + st, _, _ = api.call("POST", path, {"text": text}, headers={"Idempotency-Key": key}) + r.check(st == 401, f"replay without session -> 401, access re-checked (got {st})") + + print("== неопределённый результат: клиент повторяет с тем же ключом ==") + key2 = uuid.uuid4().hex + try: + api.call("POST", path, {"text": "таймаут?"}, token=alice["token"], headers={"Idempotency-Key": key2}, + timeout=0.001) + except OSError: + pass # ответ не дождались: записано или нет — неизвестно + st, again, _ = api.call("POST", path, {"text": "таймаут?"}, token=alice["token"], headers={"Idempotency-Key": key2}) + r.check(st == 201, "retry after uncertain result -> 201") + r.check(sum(m["text"] == "таймаут?" for m in history(path, alice["token"])) == 1, "still exactly one message") + r.finish() + + +if __name__ == "__main__": + main() diff --git a/student-tests/loadgen.py b/student-tests/loadgen.py new file mode 100644 index 00000000..b76e62dd --- /dev/null +++ b/student-tests/loadgen.py @@ -0,0 +1,110 @@ +""" +Генератор записей для экспериментов отказа и rolling update (lab3, уровень «4»). + +Несколько потоков в замкнутом цикле отправляют сообщения через LB. У каждого +сообщения свой Idempotency-Key; если ответ не получен (ошибка/таймаут/5xx), +поток повторяет ТОТ ЖЕ запрос с ТЕМ ЖЕ ключом — так проверяется, что +неопределённая запись безопасно повторяется и не даёт дублей. +""" +import threading +import time +import uuid +from urllib.parse import quote + +from common import Api + + +class LoadGen: + def __init__(self, api: Api, token: str, chat_id: str, workers: int = 4, timeout: float = 2.0): + self.api, self.token, self.chat_id = api, token, chat_id + self.path = f"/api/v1/chats/{chat_id}/messages" + self.workers, self.timeout = workers, timeout + self.stop_event = threading.Event() + self.lock = threading.Lock() + self.ok = [] # (t, instance, message) + self.errors = [] # (t, reason) + self.retried = 0 # сколько раз повторяли тот же ключ + self.threads = [] + self.t0 = None + + def _worker(self, w: int): + i = 0 + while not self.stop_event.is_set(): + key = uuid.uuid4().hex + text = f"load-{w}-{i}-{key[:8]}" + first = True + while not self.stop_event.is_set(): + if not first: + with self.lock: + self.retried += 1 + first = False + try: + st, body, rh = self.api.call("POST", self.path, {"text": text}, token=self.token, + headers={"Idempotency-Key": key}, timeout=self.timeout) + except OSError as exc: + st, body, rh = None, None, None + reason = type(exc).__name__ + else: + reason = f"HTTP {st}" + now = time.monotonic() + if st == 201: + with self.lock: + self.ok.append((now, rh.get("X-Instance-Id", ""), body)) + break + with self.lock: + self.errors.append((now, reason)) + time.sleep(0.1) # повтор с тем же ключом + i += 1 + + def start(self): + self.t0 = time.monotonic() + for w in range(self.workers): + t = threading.Thread(target=self._worker, args=(w,), daemon=True) + t.start() + self.threads.append(t) + + def stop(self): + self.stop_event.set() + for t in self.threads: + t.join(timeout=self.timeout + 2) + + # ---------------------------------------------------------------- метрики + def window(self, a: float, b: float) -> dict: + """Успехи/ошибки в окне [a, b) секунд от старта нагрузки.""" + ok = [x for x in self.ok if a <= x[0] - self.t0 < b] + err = [x for x in self.errors if a <= x[0] - self.t0 < b] + dur = max(b - a, 1e-9) + return {"successful": len(ok), "errors": len(err), "successful_rps": round(len(ok) / dur, 1)} + + def max_gap_after(self, t_abs: float) -> float: + """Самый длинный промежуток без успешной записи после момента t_abs (сек).""" + times = [t_abs] + sorted(x[0] for x in self.ok if x[0] >= t_abs) + if len(times) == 1: + return float("inf") + return round(max(b - a for a, b in zip(times, times[1:])), 3) + + def first_success_after(self, t_abs: float): + later = sorted(x[0] for x in self.ok if x[0] >= t_abs) + return round(later[0] - t_abs, 3) if later else None + + def instances_after(self, t_abs: float) -> list: + return [x[1] for x in sorted(self.ok) if x[0] >= t_abs] + + def verify(self) -> dict: + """Все подтверждённые сообщения есть в истории без изменений, дублей нет.""" + items, cursor = [], None + while True: + q = "?limit=100" + (f"&cursor={quote(cursor, safe='')}" if cursor else "") + st, page, _ = self.api.call("GET", self.path + q, token=self.token) + assert st == 200, f"history read failed: {st}" + items += page["items"] + cursor = page["next_cursor"] + if cursor is None: + break + by_id = {m["id"]: m for m in items} + texts = [m["text"] for m in items] + confirmed = [x[2] for x in self.ok] + lost = [m for m in confirmed if by_id.get(m["id"]) != m] + return {"history_messages": len(items), "confirmed": len(confirmed), + "lost_or_changed": len(lost), "duplicate_texts": len(texts) - len(set(texts)), + "retries_with_same_key": self.retried} diff --git a/student-tests/logout_cache.py b/student-tests/logout_cache.py new file mode 100644 index 00000000..04ae3725 --- /dev/null +++ b/student-tests/logout_cache.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +""" +Logout при приостановленном Redis (замечание к app/sessions.py). + +Сценарий преподавателя: прогреть сессию в кэше, приостановить Redis, сделать +logout, восстановить Redis и проверить старый токен. +Требование: 204 только при гарантированном отзыве; после 204 старый токен +никогда не принимается, в том числе после восстановления Redis. + + python student-tests/logout_cache.py --base-url http://localhost:8080 +(по умолчанию сам делает docker compose pause/unpause redis) +""" +import argparse +import shlex +import subprocess +import time + +from common import Api, Report + +COMPOSE = "docker compose --env-file .env" + + +def sh(cmd: str): + print(f" $ {cmd}") + subprocess.run(shlex.split(cmd), check=True, stdout=subprocess.DEVNULL) + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + ap.add_argument("--pause-redis", default=f"{COMPOSE} pause redis") + ap.add_argument("--unpause-redis", default=f"{COMPOSE} unpause redis") + args = ap.parse_args() + api, r = Api(args.base_url), Report() + + user = api.new_user("logoutcache") + token = user["token"] + for _ in range(2): # первый запрос кладёт сессию в Redis, второй читает из кэша + st, _, _ = api.call("GET", "/api/v1/users/me", token=token) + r.check(st == 200, "session is warmed up in cache") + + print("== Redis приостановлен ==") + sh(args.pause_redis) + try: + st_logout, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=token) + r.check(st_logout != 204, + f"logout is NOT confirmed while cache cannot be invalidated (got {st_logout}, expected 503)") + finally: + sh(args.unpause_redis) + time.sleep(0.5) + + print("== Redis восстановлен ==") + st, _, _ = api.call("GET", "/api/v1/users/me", token=token) + if st_logout == 204: + r.check(st == 401, f"after a 204 the old token is rejected after Redis recovery (got {st})") + else: + r.check(st == 200, f"unconfirmed logout left the session consistent and valid (got {st})") + st, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=token) + r.check(st == 204, f"retry logout after Redis recovery -> 204 (got {st})") + st, _, _ = api.call("GET", "/api/v1/users/me", token=token) + r.check(st == 401, f"old token after confirmed logout -> 401, no stale cache copy (got {st})") + st, _, _ = api.call("GET", "/api/v1/users/me", token=token) + r.check(st == 401, f"old token still rejected on repeat (got {st})") + r.finish() + + +if __name__ == "__main__": + main() diff --git a/student-tests/orphans.py b/student-tests/orphans.py new file mode 100644 index 00000000..233d4cad --- /dev/null +++ b/student-tests/orphans.py @@ -0,0 +1,125 @@ +#!/usr/bin/env python3 +""" +Согласованность S3 ↔ PostgreSQL при сбоях (lab4, уровень «4»). +Сам управляет контейнерами через docker compose; запускать из корня репозитория: + + docker compose --env-file .env --profile fault up -d api-fault + python student-tests/orphans.py --base-url http://localhost:8080 --fault-url http://localhost:8082 + +Сценарии: + 1. Прерванная загрузка (клиент оборвал тело) → в S3 и журнале ничего не появилось. + 2. PUT в S3 прошёл, запись в БД упала (db-error-after-s3-put) → 503, API сразу + компенсирует: объект и строка журнала удалены, вложения нет. + 3. PUT прошёл, процесс убит до COMMIT (crash-after-s3-put, os._exit) → остаётся + объект + строка upload_intents (известная сирота). Janitor: + - с рабочим grace period (900 c) её НЕ трогает (может быть живая загрузка); + - dry-run показывает, что удалит, и ничего не меняет; + - после истечения grace удаляет объект и строку; повтор — без изменений. + 4. Объект без журнала и без метаданных (страховка) → находится обходом bucket + (--scan-bucket) и удаляется только после grace. + 5. Готовые вложения не удаляются никогда: после всех проходов скачиваются, sha256 совпадает. +""" +import argparse +import time + +from common import SAMPLE_PNG, Api, Report, compose, janitor, raw_http, sha256, tool, upload + + +def wait_ready(api: Api, seconds: int = 60) -> bool: + deadline = time.time() + seconds + while time.time() < deadline: + try: + if api.raw("GET", "/health/ready", timeout=3)[0] == 200: + return True + except OSError: + pass + time.sleep(1) + return False + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + ap.add_argument("--fault-url", default="http://localhost:8082") + ap.add_argument("--grace", type=int, default=5, help="маленький grace для теста (с)") + args = ap.parse_args() + api, fault, r = Api(args.base_url), Api(args.fault_url), Report() + r.check(wait_ready(fault, 60), "fault replica (profile fault) is ready on --fault-url") + + user = api.new_user("orphan") + st, chat, _ = api.call("POST", "/api/v1/chats", {"title": "orphans", "member_ids": [user["id"]]}, + token=user["token"]) + st, keep, _ = upload(api, user["token"], chat["id"], SAMPLE_PNG, "keep.png") + r.check(st == 201, "committed attachment that must survive every cleanup") + # Сначала дочищаем всё старое, чтобы считать объекты от нуля. + janitor("--grace-seconds", "0", "--scan-bucket") + base = tool("stats") + print(" baseline:", base) + + print("== 1. прерванная загрузка ==") + path = f"/api/v1/chats/{chat['id']}/attachments?filename=cut.png" + raw_http(args.base_url, "POST", path, + {"Authorization": "Bearer " + user["token"], "Content-Type": "image/png", + "Content-Length": str(len(SAMPLE_PNG))}, + chunks=[SAMPLE_PNG[:20000]], close_after_send=True) + time.sleep(2) + now = tool("stats") + r.check(now == base, f"no object, no metadata, no journal row after interrupted upload ({now})") + + print("== 2. отказ БД после PUT: немедленная компенсация ==") + st, body, _ = upload(fault, user["token"], chat["id"], SAMPLE_PNG, "dbfail.png", + headers={"X-Fault-Inject": "db-error-after-s3-put"}) + r.check(st == 503, f"upload answered 503, not 201 (got {st})") + now = tool("stats") + r.check(now == base, f"object deleted by compensation, journal clean ({now})") + + print("== 3. процесс убит между PUT и COMMIT ==") + try: + st, _, _ = upload(fault, user["token"], chat["id"], SAMPLE_PNG, "crash.png", + headers={"X-Fault-Inject": "crash-after-s3-put"}, timeout=20) + except OSError: + st = None + r.check(st != 201, f"client did NOT get 201 (got {st})") + time.sleep(1) + now = tool("stats") + r.check(now["objects"] == base["objects"] + 1 and now["upload_intents"] == base["upload_intents"] + 1 + and now["attachments"] == base["attachments"], + f"orphan object + journal row left behind, no metadata ({now})") + s = janitor() # рабочий grace period + r.check(s["objects_deleted"] == 0 and tool("stats") == now, + f"default grace {s['grace_seconds']} s: fresh upload is NOT touched") + time.sleep(args.grace + 1) + s = janitor("--grace-seconds", str(args.grace), "--dry-run") + r.check(s["would_delete_objects"] == 1 and tool("stats") == now, "dry-run reports 1 object, changes nothing") + s = janitor("--grace-seconds", str(args.grace)) + after = tool("stats") + r.check(s["objects_deleted"] == 1 and after == base, f"janitor removed orphan + journal row ({s})") + s = janitor("--grace-seconds", str(args.grace)) + r.check(s["objects_deleted"] == 0 and tool("stats") == base, "second run is a no-op (idempotent)") + + print("== 4. объект без журнала (страховочный обход bucket) ==") + compose("exec", "-T", "api", "python", "-c", + "import uuid; from app import storage; storage.init(); " + "storage.client().put_object(Bucket=storage.settings.s3_bucket, " + "Key=storage.object_key(uuid.uuid4()), Body=b'lost')") + r.check(tool("stats")["objects"] == base["objects"] + 1, "untracked object planted") + s = janitor("--scan-bucket", "--grace-seconds", "3600") + r.check(s["orphans_found"] == 0, "scan with grace 1 h ignores a fresh object") + time.sleep(args.grace + 1) + s = janitor("--scan-bucket", "--grace-seconds", str(args.grace), "--dry-run") + r.check(s["orphans_found"] == 1 and tool("stats")["objects"] == base["objects"] + 1, "scan dry-run finds 1") + s = janitor("--scan-bucket", "--grace-seconds", str(args.grace)) + r.check(s["objects_deleted"] == 1 and tool("stats") == base, f"scan deletes the untracked object ({s})") + + print("== 5. готовые вложения не тронуты ==") + st, raw, _ = api.raw("GET", f"/api/v1/attachments/{keep['id']}/content", + headers={"Authorization": "Bearer " + user["token"]}) + r.check(st == 200 and sha256(raw) == keep["sha256"], "committed attachment still downloads, sha256 matches") + state = tool("state", keep["id"]) + r.check(state == {"object_exists": True, "attachment_row": True, "upload_intent": False}, + f"object + metadata, no journal row ({state})") + r.finish() + + +if __name__ == "__main__": + main() diff --git a/student-tests/outage.py b/student-tests/outage.py new file mode 100644 index 00000000..f6e73438 --- /dev/null +++ b/student-tests/outage.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python3 +""" +Недоступность зависимостей (уровень «4»). Сам останавливает и запускает контейнеры: + python student-tests/outage.py --base-url http://localhost:8080 + +1. Redis остановлен → API работает в обход кэша (сессии читаются из PostgreSQL). +2. PostgreSQL остановлен → защищённые запросы получают ограниченную ошибку 503, + неизвестный токен НЕ принимается (никогда 200), /health/ready = 503. +3. PostgreSQL запущен снова → тот же токен снова работает, данные на месте. +""" +import argparse +import shlex +import subprocess +import time +import uuid + +from common import Api, Report + +COMPOSE = "docker compose --env-file .env" + + +def sh(cmd: str): + print(f" $ {cmd}") + subprocess.run(shlex.split(cmd), check=True, stdout=subprocess.DEVNULL) + + +def wait_ready(api: Api, seconds=90): + deadline = time.time() + seconds + while time.time() < deadline: + try: + if api.raw("GET", "/health/ready", timeout=3)[0] == 200: + return True + except OSError: + pass + time.sleep(1) + return False + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + ap.add_argument("--stop-redis", default=f"{COMPOSE} stop redis") + ap.add_argument("--start-redis", default=f"{COMPOSE} start redis") + ap.add_argument("--stop-db", default=f"{COMPOSE} stop postgres") + ap.add_argument("--start-db", default=f"{COMPOSE} start postgres") + args = ap.parse_args() + api, r = Api(args.base_url), Report() + + user = api.new_user("outage") + st, chat, _ = api.call("POST", "/api/v1/chats", {"title": "outage", "member_ids": [user["id"]]}, token=user["token"]) + path = f"/api/v1/chats/{chat['id']}/messages" + api.call("POST", path, {"text": "before outage"}, token=user["token"]) + + print("== 1. Redis недоступен ==") + sh(args.stop_redis) + try: + st, _, _ = api.call("GET", "/api/v1/users/me", token=user["token"]) + r.check(st == 200, "valid token still works without Redis (cache bypassed)") + st, _, _ = api.call("POST", path, {"text": "without redis"}, token=user["token"]) + r.check(st == 201, "writes still work without Redis") + fresh = api.register("noredis") + st, sess, _ = api.login(fresh["username"], fresh["password"]) + r.check(st == 201, "login works without Redis") + st, _, _ = api.call("GET", "/api/v1/users/me", token="forged-" + uuid.uuid4().hex) + r.check(st == 401, "forged token still rejected without Redis") + finally: + sh(args.start_redis) + + print("== 2. PostgreSQL недоступен ==") + sh(args.stop_db) + try: + time.sleep(1) + st, _, _ = api.call("GET", path, token=user["token"]) + r.check(st == 503, f"history without DB -> 503, not a hang (got {st})") + st, _, _ = api.call("GET", "/api/v1/users/me", token="forged-" + uuid.uuid4().hex) + r.check(st in (401, 503), f"unknown token is never trusted without DB (got {st})") + st, _, _ = api.call("GET", "/api/v1/users/me") + r.check(st == 401, "anonymous request -> 401") + st = api.raw("GET", "/health/ready")[0] + r.check(st == 503, "/health/ready -> 503") + st = api.raw("GET", "/health/live")[0] + r.check(st == 200, "/health/live -> 200 (process is alive)") + finally: + sh(args.start_db) + + print("== 3. восстановление ==") + r.check(wait_ready(api), "/health/ready back to 200") + st, page, _ = api.call("GET", path, token=user["token"]) + texts = [m["text"] for m in (page or {}).get("items", [])] + r.check(st == 200 and "before outage" in texts and "without redis" in texts, + "same token reads the same history after DB is back") + r.finish() + + +if __name__ == "__main__": + main() diff --git a/student-tests/race.py b/student-tests/race.py new file mode 100644 index 00000000..d65b8ab7 --- /dev/null +++ b/student-tests/race.py @@ -0,0 +1,46 @@ +#!/usr/bin/env python3 +""" +Конкурентная запись: 10 клиентов параллельно отправляют по 10 сообщений. +Ожидаем ровно 100 уникальных сообщений в истории. + python student-tests/race.py --base-url http://localhost:8080 +""" +import argparse +from concurrent.futures import ThreadPoolExecutor + +from common import Api + +CLIENTS, PER_CLIENT = 10, 10 + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + api = Api(ap.parse_args().base_url) + user = api.new_user("race") + st, chat, _ = api.call("POST", "/api/v1/chats", {"title": "race", "member_ids": [user["id"]]}, token=user["token"]) + mpath = f"/api/v1/chats/{chat['id']}/messages" + + def worker(w): + return [api.call("POST", mpath, {"text": f"c{w}-m{i}"}, token=user["token"])[0] for i in range(PER_CLIENT)] + + with ThreadPoolExecutor(max_workers=CLIENTS) as pool: + codes = [c for batch in pool.map(worker, range(CLIENTS)) for c in batch] + + ids, texts, cursor = [], [], None + while True: + st, page, _ = api.call("GET", f"{mpath}?limit=50" + (f"&cursor={cursor}" if cursor else ""), token=user["token"]) + ids += [m["id"] for m in page["items"]] + texts += [m["text"] for m in page["items"]] + cursor = page["next_cursor"] + if cursor is None: + break + expected = {f"c{w}-m{i}" for w in range(CLIENTS) for i in range(PER_CLIENT)} + ok = codes.count(201) == 100 and len(ids) == 100 and len(set(ids)) == 100 and set(texts) == expected + print(f"sent=100 accepted={codes.count(201)} received={len(ids)} unique_ids={len(set(ids))} " + f"all_texts_present={set(texts) == expected}") + print("PASS" if ok else "FAIL") + raise SystemExit(0 if ok else 1) + + +if __name__ == "__main__": + main() diff --git a/student-tests/rollback_check.py b/student-tests/rollback_check.py new file mode 100644 index 00000000..0a8a0994 --- /dev/null +++ b/student-tests/rollback_check.py @@ -0,0 +1,52 @@ +""" +Rollback составной операции «создать чат + участников» (уровень «4»). + +Создаём чат, где последний участник — несуществующий пользователь. Проверку +приложения нарочно обходим и вызываем запись напрямую: первый INSERT в chats +проходит, а вставка участника падает на внешнем ключе. Ожидаем, что транзакция +откатилась целиком: ни чата, ни участников в базе нет. + +Запуск внутри контейнера API (у него есть доступ к БД и коду): + docker compose cp student-tests/rollback_check.py api:/tmp/rollback_check.py + docker compose exec api python /tmp/rollback_check.py +Локально без Docker: python student-tests/rollback_check.py +""" +import asyncio +import sys +import uuid +from pathlib import Path + +sys.path.insert(0, str(Path.cwd())) +import psycopg # noqa: E402 + +from app import repo # noqa: E402 +from app.config import settings # noqa: E402 + + +async def main() -> int: + title = "rollback-" + uuid.uuid4().hex[:8] + async with await psycopg.AsyncConnection.connect(settings.database_url) as conn: + creator = await repo.create_user(conn, "rb_" + uuid.uuid4().hex[:10], "rb", "x") + await conn.commit() + ghost = uuid.uuid4() # такого пользователя нет + try: + async with conn.transaction(): + await repo.insert_chat(conn, title, [uuid.UUID(creator["id"]), ghost], creator["id"]) + print("FAIL - insert unexpectedly succeeded") + return 1 + except psycopg.errors.ForeignKeyViolation: + print(" ok - insert of unknown member failed on foreign key") + cur = await conn.execute( + "SELECT count(*) FROM chats WHERE title = %s", (title,)) + chats = (await cur.fetchone())[0] + cur = await conn.execute( + "SELECT count(*) FROM chat_members m JOIN chats c ON c.id = m.chat_id WHERE c.title = %s", (title,)) + members = (await cur.fetchone())[0] + ok = chats == 0 and members == 0 + print(f" {'ok ' if ok else 'FAIL'} - after rollback: chats={chats}, members={members} (expected 0, 0)") + print("PASS" if ok else "FAIL") + return 0 if ok else 1 + + +if __name__ == "__main__": + raise SystemExit(asyncio.run(main())) diff --git a/student-tests/rolling_update.py b/student-tests/rolling_update.py new file mode 100644 index 00000000..34a92f9a --- /dev/null +++ b/student-tests/rolling_update.py @@ -0,0 +1,133 @@ +#!/usr/bin/env python3 +""" +Поочерёдная замена реплик API (rolling update) под нагрузкой (lab3, уровень «4»). + +Compose не делает rolling update сам, поэтому замена выполняется по шагам: + 1. собрать новый образ (docker compose build api); + 2. для каждой старой реплики: + поднять ОДНУ новую (up --scale api=N+1 --no-recreate) → дождаться healthy + и того, что LB её обслуживает → остановить старую (SIGTERM, graceful) → удалить; + 3. всё это время нагрузка пишет сообщения через LB и повторяет неудачные + запросы с тем же Idempotency-Key. +Итог: ошибки/RPS во время замены, все реплики на новом образе, нет потерь и дублей. + +Миграции: перед заменой выполняется сервис migrate (однократно). Новые миграции +должны быть совместимы с ещё работающей старой версией (только добавление). + + python student-tests/rolling_update.py --base-url http://localhost:8080 --output evidence/rolling-update.json +""" +import argparse +import json +import shlex +import subprocess +import time + +from common import Api, Report +from failover_each import served_instances +from loadgen import LoadGen + +COMPOSE = "docker compose --env-file .env" + + +def sh(cmd: str) -> str: + print(f" $ {cmd}") + return subprocess.run(shlex.split(cmd), check=True, capture_output=True, text=True).stdout + + +def api_ids() -> list: + return [x.strip() for x in sh(f"{COMPOSE} ps -q api").splitlines() if x.strip()] + + +def image_of(cid: str) -> str: + return sh(f"docker inspect -f {{{{.Image}}}} {cid}").strip() + + +def wait_healthy(cid: str, seconds: float = 90) -> bool: + deadline = time.monotonic() + seconds + while time.monotonic() < deadline: + if sh(f"docker inspect -f {{{{.State.Health.Status}}}} {cid}").strip() == "healthy": + return True + time.sleep(1) + return False + + +def wait_served(api: Api, iid: str, seconds: float = 60) -> bool: + deadline = time.monotonic() + seconds + while time.monotonic() < deadline: + if iid in served_instances(api, 10): + return True + time.sleep(0.5) + return False + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + ap.add_argument("--workers", type=int, default=4) + ap.add_argument("--no-build", action="store_true", help="не пересобирать образ") + ap.add_argument("--output", default=None) + args = ap.parse_args() + api, r = Api(args.base_url), Report() + + if not args.no_build: + sh(f"{COMPOSE} build api") + sh(f"{COMPOSE} run --rm migrate") # однократные миграции до замены + new_image = sh("docker image inspect -f {{.Id}} mtusi-messenger:lab4").strip() + old = api_ids() + n = len(old) + r.check(n >= 2, f"{n} replicas before update") + old_images = {cid[:12]: image_of(cid) for cid in old} + + user = api.new_user("rolling") + st, chat, _ = api.call("POST", "/api/v1/chats", {"title": "rolling", "member_ids": [user["id"]]}, + token=user["token"]) + gen = LoadGen(api, user["token"], chat["id"], workers=args.workers) + gen.start() + time.sleep(3) + t_begin = time.monotonic() + steps = [] + for cid in old: + before = set(api_ids()) + sh(f"{COMPOSE} up -d --no-deps --no-recreate --scale api={len(before) + 1} api") + new = sorted(set(api_ids()) - before) + r.check(len(new) == 1, f"one new replica started for {cid[:12]}") + new_id = new[0] + healthy = wait_healthy(new_id) + served = wait_served(api, new_id[:12]) + t0 = time.monotonic() + sh(f"docker stop -t 15 {cid}") + sh(f"docker rm {cid}") + steps.append({"old": cid[:12], "new": new_id[:12], "new_healthy": healthy, "new_served_by_lb": served, + "old_stop_seconds": round(time.monotonic() - t0, 2)}) + r.check(healthy and served, f"new replica {new_id[:12]} healthy and in LB before old {cid[:12]} stops") + t_end = time.monotonic() + time.sleep(3) + gen.stop() + + final = api_ids() + rel_a, rel_b = t_begin - gen.t0, t_end - gen.t0 + result = { + "replicas_before": sorted(old_images), "replicas_after": sorted(c[:12] for c in final), + "all_on_new_image": all(image_of(c) == new_image for c in final), + "steps": steps, + "update_duration_s": round(t_end - t_begin, 1), + "before_update": gen.window(0, rel_a), + "during_update": gen.window(rel_a, rel_b), + "after_update": gen.window(rel_b, rel_b + 3), + "max_gap_without_success_s": gen.max_gap_after(t_begin), + "instances_serving_at_end": sorted(set(gen.instances_after(t_end))), + **gen.verify(), + } + print(json.dumps(result, ensure_ascii=False, indent=2)) + r.check(len(final) == n, f"replica count restored to {n}") + r.check(result["all_on_new_image"], "all replicas run the new image") + r.check(not set(result["instances_serving_at_end"]) & set(old_images), "old replicas no longer serve traffic") + r.check(result["lost_or_changed"] == 0 and result["duplicate_texts"] == 0, "no lost or duplicated writes") + if args.output: + with open(args.output, "w", encoding="utf-8") as f: + json.dump(result, f, ensure_ascii=False, indent=2) + r.finish() + + +if __name__ == "__main__": + main() diff --git a/student-tests/run.py b/student-tests/run.py new file mode 100644 index 00000000..312d17cb --- /dev/null +++ b/student-tests/run.py @@ -0,0 +1,122 @@ +#!/usr/bin/env python3 +""" +Собственные тесты lab2 (запуск одной командой): + python student-tests/run.py --base-url http://localhost:8080 + +Негативные сценарии lab1 на новой аутентификации + проверки уровня «4»: +неверный пароль, logout, X-User-Id/Basic не дают доступ, гонка регистрации. +""" +import argparse +import base64 +import json +import uuid +from concurrent.futures import ThreadPoolExecutor + +from common import PASSWORD, Api, Report + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + api = Api(ap.parse_args().base_url) + r = Report() + + alice, bob, eve = api.new_user("alice"), api.new_user("bob"), api.new_user("eve") + st, chat, _ = api.call("POST", "/api/v1/chats", + {"title": "own tests", "member_ids": [alice["id"], bob["id"]]}, token=alice["token"]) + assert st == 201, st + mpath = f"/api/v1/chats/{chat['id']}/messages" + + print("== аутентификация ==") + st, _, rh = api.login(alice["username"], "Wrong-password-123") + r.check(st == 401 and rh.get("WWW-Authenticate", "").startswith("Basic"), "wrong password -> 401 + Basic challenge") + st, _, _ = api.login("no_such_user_" + uuid.uuid4().hex[:8], PASSWORD) + r.check(st == 401, "unknown user -> 401 (same as wrong password)") + st, _, rh = api.call("GET", "/api/v1/users/me") + r.check(st == 401 and rh.get("WWW-Authenticate", "").startswith("Bearer"), "no token -> 401 + Bearer challenge") + st, _, _ = api.call("GET", "/api/v1/users/me", headers={"X-User-Id": alice["id"]}) + r.check(st == 401, "X-User-Id alone gives no access") + st, _, _ = api.call("GET", "/api/v1/users/me", token="forged-" + uuid.uuid4().hex) + r.check(st == 401, "unknown/forged token -> 401") + basic = base64.b64encode(f"{alice['username']}:{alice['password']}".encode()).decode() + st, _, _ = api.call("GET", "/api/v1/users/me", headers={"Authorization": "Basic " + basic}) + r.check(st == 401, "Basic on business endpoint -> 401") + st, me, _ = api.call("GET", "/api/v1/users/me", token=alice["token"], headers={"X-User-Id": eve["id"]}) + r.check(st == 200 and me["id"] == alice["id"], "X-User-Id cannot override bearer identity") + st, _, _ = api.call("POST", "/api/v1/users", {"username": "short_pw_" + uuid.uuid4().hex[:6], + "display_name": "x", "password": "short"}) + r.check(st == 400, "password shorter than 12 -> 400") + + print("== logout ==") + tmp = api.new_user("logout") + st, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=tmp["token"]) + r.check(st == 204, "logout -> 204") + st, _, _ = api.call("GET", "/api/v1/users/me", token=tmp["token"]) + r.check(st == 401, "token after logout -> 401") + st, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=tmp["token"]) + r.check(st == 401, "second logout -> 401") + + print("== гонка регистрации одного username ==") + name = "race_" + uuid.uuid4().hex[:10] + + def reg(_): + st, _, _ = api.call("POST", "/api/v1/users", {"username": name, "display_name": "r", "password": PASSWORD}) + return st + + with ThreadPoolExecutor(max_workers=20) as pool: + codes = list(pool.map(reg, range(20))) + r.check(codes.count(201) == 1 and codes.count(409) == 19, + f"20 parallel registrations -> one 201, nineteen 409 (got {sorted(codes)})") + + print("== ошибки и доступ (из lab1) ==") + st, _, _ = api.raw("POST", "/api/v1/users", b"{not json", {"Content-Type": "application/json"}) + r.check(st == 400, "malformed JSON -> 400") + st, _, _ = api.call("POST", "/api/v1/users", {"username": alice["username"], "display_name": "d", "password": PASSWORD}) + r.check(st == 409, "duplicate username -> 409") + st, _, _ = api.call("POST", mpath, {"text": " "}, token=alice["token"]) + r.check(st == 400, "blank message -> 400") + st, _, _ = api.call("POST", mpath, {"text": "x", "sender_id": eve["id"]}, token=alice["token"]) + r.check(st == 400, "sender_id in body is rejected") + st, _, _ = api.call("POST", mpath, {"text": "чужое"}, token=eve["token"]) + r.check(st == 404, "outsider POST to foreign chat -> 404") + st, _, _ = api.call("GET", mpath, token=eve["token"]) + r.check(st == 404, "outsider GET foreign history -> 404") + st, _, _ = api.call("GET", "/api/v1/chats/not-a-uuid", token=alice["token"]) + r.check(st == 400, "invalid chat uuid -> 400") + + print("== пагинация ==") + for i in range(5): + api.call("POST", mpath, {"text": f"m{i}"}, token=bob["token"]) + seen, cursor, pages = [], None, 0 + while pages < 10: + st, page, _ = api.call("GET", f"{mpath}?limit=2" + (f"&cursor={cursor}" if cursor else ""), token=alice["token"]) + pages += 1 + seen += [m["id"] for m in page["items"]] + cursor = page["next_cursor"] + if cursor is None: + break + r.check(len(seen) == 5 and len(set(seen)) == 5 and pages == 3, "5 messages / limit 2 -> 3 pages, no duplicates") + st, other, _ = api.call("POST", "/api/v1/chats", {"title": "other", "member_ids": [alice["id"]]}, token=alice["token"]) + st, p, _ = api.call("GET", f"{mpath}?limit=1", token=alice["token"]) + st, _, _ = api.call("GET", f"/api/v1/chats/{other['id']}/messages?cursor={p['next_cursor']}", token=alice["token"]) + r.check(st == 400, "cursor from another chat -> 400") + + print("== Content-Type ==") + body = json.dumps({"username": "ct_" + uuid.uuid4().hex[:8], "display_name": "c", "password": PASSWORD}).encode() + st, _, _ = api.raw("POST", "/api/v1/users", body, {"Content-Type": "text/plain"}) + r.check(st == 415, f"valid JSON with text/plain -> 415 (got {st})") + st, _, _ = api.raw("POST", mpath, json.dumps({"text": "x"}).encode(), + {"Content-Type": "text/plain", "Authorization": "Bearer " + alice["token"]}) + r.check(st == 415, f"message with text/plain -> 415 (got {st})") + st, _, _ = api.raw("POST", "/api/v1/chats", b"{}", {"Content-Type": "text/plain"}) + r.check(st == 401, f"text/plain without token -> 401 first (got {st})") + st, _, _ = api.raw("POST", mpath, json.dumps({"text": "utf8"}).encode(), + {"Content-Type": "application/json; charset=utf-8", "Authorization": "Bearer " + alice["token"], + "Idempotency-Key": uuid.uuid4().hex}) + r.check(st == 201, f"application/json; charset=utf-8 accepted (got {st})") + + r.finish() + + +if __name__ == "__main__": + main() diff --git a/student-tests/s3_outage.py b/student-tests/s3_outage.py new file mode 100644 index 00000000..7e044453 --- /dev/null +++ b/student-tests/s3_outage.py @@ -0,0 +1,83 @@ +#!/usr/bin/env python3 +""" +Недоступность S3 (lab4). Сам останавливает и запускает MinIO; из корня репозитория: + + python student-tests/s3_outage.py --base-url http://localhost:8080 + +Ожидание: пока MinIO остановлен, загрузка и скачивание дают быстрый 503 в формате +контракта (не зависание и не 500), а текстовая часть мессенджера, метаданные +вложений и /health/ready работают (S3 не критичен для обязательного текстового пути). +После старта MinIO всё снова работает, ранее загруженный файл не изменился. +Брошенная во время отказа запись журнала дочищается janitor после grace period. +""" +import argparse +import time + +from common import SAMPLE_PNG, Api, Report, compose, janitor, sha256, tool, upload + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + args = ap.parse_args() + api, r = Api(args.base_url), Report() + u = api.new_user("s3down") + T = u["token"] + st, chat, _ = api.call("POST", "/api/v1/chats", {"title": "s3 outage", "member_ids": [u["id"]]}, token=T) + st, before, _ = upload(api, T, chat["id"], SAMPLE_PNG, "before.png") + r.check(st == 201, "upload before outage") + content = f"/api/v1/attachments/{before['id']}/content" + + print("== MinIO остановлен ==") + compose("stop", "s3") + try: + t0 = time.monotonic() + st, body, _ = upload(api, T, chat["id"], SAMPLE_PNG, "during.png", timeout=30) + took = time.monotonic() - t0 + r.check(st == 503 and body and body["error"]["code"] == "unavailable", f"upload -> 503 unavailable (got {st})") + r.check(took < 15, f"bounded by timeouts, not a hang ({took:.1f} s)") + st, _, _ = api.raw("GET", content, headers={"Authorization": "Bearer " + T}, timeout=30) + r.check(st == 503, f"download -> 503 (got {st})") + st, meta, _ = api.call("GET", f"/api/v1/attachments/{before['id']}", token=T) + r.check(st == 200 and meta["sha256"] == before["sha256"], "metadata still served from PostgreSQL") + st, _, _ = api.call("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "S3 лежит, а чат работает"}, token=T) + r.check(st == 201, "text messages still work") + st, _, _ = api.call("POST", f"/api/v1/chats/{chat['id']}/messages", + {"text": "с вложением", "attachment_ids": [before["id"]]}, token=T) + r.check(st == 201, "message referencing an existing attachment still works (metadata only)") + r.check(api.raw("GET", "/health/ready")[0] == 200, "/health/ready = 200 (S3 is not critical for text path)") + finally: + compose("start", "s3") + + print("== MinIO снова работает ==") + # После старта MinIO каждая реплика может ещё до S3_BREAKER_SECONDS (5 c) отвечать 503: + # предохранитель закрывается по таймеру. Поэтому ждём, пока ОБЕ реплики восстановятся: + # несколько успешных загрузок подряд (LB чередует реплики). + t0 = time.monotonic() + ok = False + for _ in range(40): + st, raw, _ = api.raw("GET", content, headers={"Authorization": "Bearer " + T}) + if st == 200: + ok = sha256(raw) == before["sha256"] + break + time.sleep(0.5) + r.check(ok, "file uploaded before outage downloads unchanged") + streak, codes = 0, [] + while time.monotonic() - t0 < 40 and streak < 4: + st, _, rh = upload(api, T, chat["id"], SAMPLE_PNG, "after.png") + codes.append(st) + streak = streak + 1 if st == 201 else 0 + if st != 201: + time.sleep(0.5) + recovered = time.monotonic() - t0 + r.check(streak >= 4, f"uploads work again on all replicas: 4 x 201 in a row after {recovered:.1f} s " + f"(codes during recovery: {codes})") + stats = tool("stats") + print(" stats:", stats) + s = janitor("--grace-seconds", "0") + r.check(s["errors"] == 0, f"janitor cleaned journal rows left by failed uploads ({s})") + r.finish() + + +if __name__ == "__main__": + main() diff --git a/student-tests/upload_memory.py b/student-tests/upload_memory.py new file mode 100644 index 00000000..34e92d4b --- /dev/null +++ b/student-tests/upload_memory.py @@ -0,0 +1,180 @@ +#!/usr/bin/env python3 +""" +Эксперимент: пик памяти API при N одновременных загрузках (lab4, уровень «4»). + + python student-tests/upload_memory.py --base-url http://localhost:8080 \ + --concurrency 10 --output evidence/upload-memory-10.json + +Гипотеза: память реплики почти не зависит от размера и числа одновременных +загрузок, потому что тело не копится в RAM (≤ UPLOAD_SPOOL_MEMORY_BYTES в памяти, +остальное во временном файле), проверка изображения потоковая, в S3 уходит поток. +Наивная реализация (`await request.body()` + `Image.open().load()`) держала бы +≥ размер файла × 2…4 на каждую загрузку: 10 × 9,5 МБ → 200–400 МБ, что больше +лимита контейнера 256 МБ (OOM). + +Методика: генерируется настоящий PNG из шума ≈9,5 МБ (почти не сжимается), +N потоков одновременно отправляют его через LB (несколько раундов), параллельно +каждые ~0,3 с читается память cgroup v2 всех контейнеров api (usage как в docker stats, anon, memory.peak). Фиксируются память +до нагрузки, пик во время и после, время ответа, коды ответов и sha256. +""" +import argparse +import json +import re +import subprocess +import threading +import time +from concurrent.futures import ThreadPoolExecutor + +from common import ROOT, Api, Report, compose, make_png, sha256, upload + +# Печатаем «имя значение»: cgroup v2, иначе v1 (старые ядра/Docker Desktop с cgroup v1). +CGROUP = ( + "if [ -f /sys/fs/cgroup/memory.current ]; then " + "echo current $(cat /sys/fs/cgroup/memory.current); " + "grep -E '^(anon|inactive_file) ' /sys/fs/cgroup/memory.stat; " + "[ -f /sys/fs/cgroup/memory.peak ] && echo peak $(cat /sys/fs/cgroup/memory.peak); " + "else M=/sys/fs/cgroup/memory; " + "echo current $(cat $M/memory.usage_in_bytes); " + "grep -E '^total_(rss|inactive_file) ' $M/memory.stat | sed -e 's/^total_rss/anon/' -e 's/^total_//'; " + "echo peak $(cat $M/memory.max_usage_in_bytes); fi") +UNITS = {"B": 1, "KiB": 1024, "MiB": 1024 ** 2, "GiB": 1024 ** 3, "kB": 1000, "MB": 1000 ** 2, "GB": 1000 ** 3} + + +def api_containers() -> list[str]: + return [c[:12] for c in compose("ps", "-q", "api").split()] + + +def _docker_stats(cid: str) -> dict: + """Запасной путь: docker stats (usage без файлового кэша).""" + out = subprocess.run(["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", cid], + capture_output=True, text=True, cwd=ROOT).stdout + m = re.match(r"\s*([\d.]+)\s*([A-Za-z]+)", out) + usage = round(float(m.group(1)) * UNITS[m.group(2)] / 1024 ** 2, 1) if m else 0.0 + return {"usage": usage, "anon": usage, "peak": None} + + +_warned: list = [] + + +def read_cgroup(cid: str) -> dict: + """Память контейнера (MiB): usage как в docker stats (current − inactive_file), + anon — память процессов без файлового кэша, peak — максимум за жизнь cgroup.""" + p = subprocess.run(["docker", "exec", cid, "sh", "-c", CGROUP], + capture_output=True, text=True, cwd=ROOT) + vals = {} + for line in p.stdout.splitlines(): + parts = line.split() + if len(parts) == 2 and parts[1].isdigit(): + vals[parts[0]] = int(parts[1]) + if "current" not in vals: + if not _warned: + _warned.append(1) + print(f" cgroup read failed (exit {p.returncode}: {p.stderr.strip()[:200]!r}); using docker stats") + return _docker_stats(cid) + mib = 1024 ** 2 + return {"usage": round((vals["current"] - vals.get("inactive_file", 0)) / mib, 1), + "anon": round(vals.get("anon", vals["current"]) / mib, 1), + "peak": round(vals["peak"] / mib, 1) if "peak" in vals else None} + + +def sample_mem(ids: list[str]) -> dict: + with ThreadPoolExecutor(max_workers=len(ids) or 1) as pool: + return dict(zip(ids, pool.map(read_cgroup, ids))) + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + ap.add_argument("--concurrency", type=int, default=10) + ap.add_argument("--rounds", type=int, default=3) + ap.add_argument("--width", type=int, default=1780, help="PNG width/height: 1780 → ≈9,5 МБ") + ap.add_argument("--output", default=None) + args = ap.parse_args() + api, r = Api(args.base_url), Report() + + data = make_png(args.width, args.width, noise=True) + digest = sha256(data) + print(f"file: {len(data)} bytes ({len(data) / 1024 ** 2:.2f} MiB), sha256 {digest[:12]}…") + u = api.new_user("memexp") + st, chat, _ = api.call("POST", "/api/v1/chats", {"title": "memory", "member_ids": [u["id"]]}, token=u["token"]) + + ids = api_containers() + idle = sample_mem(ids) + print("idle MiB:", idle) + peak = {k: {"usage": v["usage"], "anon": v["anon"]} for k, v in idle.items()} + samples = [] + stop = threading.Event() + + def sampler(): + t0 = time.monotonic() + while not stop.is_set(): + m = sample_mem(ids) + samples.append({"t": round(time.monotonic() - t0, 2), **m}) + for k, v in m.items(): + for f in ("usage", "anon"): + peak[k][f] = max(peak[k][f], v[f]) + time.sleep(0.2) + + th = threading.Thread(target=sampler, daemon=True) + th.start() + results = [] + + def one(i): + t = time.monotonic() + try: + st, body, rh = upload(api, u["token"], chat["id"], data, f"noise-{i}.png", timeout=120) + except OSError as exc: + return {"status": None, "error": type(exc).__name__, "seconds": round(time.monotonic() - t, 2)} + return {"status": st, "seconds": round(time.monotonic() - t, 2), + "sha_ok": bool(body) and body.get("sha256") == digest, + "instance": rh.get("X-Instance-Id"), "id": (body or {}).get("id")} + + t_start = time.monotonic() + with ThreadPoolExecutor(max_workers=args.concurrency) as pool: + for rnd in range(args.rounds): + results += list(pool.map(one, range(rnd * args.concurrency, (rnd + 1) * args.concurrency))) + elapsed = time.monotonic() - t_start + time.sleep(2) + stop.set() + th.join() + after = sample_mem(ids) + + ok = [x for x in results if x["status"] == 201] + lat = sorted(x["seconds"] for x in ok) + summary = { + "file_bytes": len(data), "concurrency": args.concurrency, "rounds": args.rounds, + "uploads": len(results), "status_counts": {str(s): sum(1 for x in results if x["status"] == s) + for s in sorted({x["status"] for x in results}, key=str)}, + "sha256_ok": sum(1 for x in ok if x["sha_ok"]), + "instances": sorted({x["instance"] for x in ok if x["instance"]}), + "elapsed_s": round(elapsed, 2), + "throughput_MiB_s": round(len(ok) * len(data) / 1024 ** 2 / elapsed, 1) if elapsed else None, + "latency_s": {"p50": lat[len(lat) // 2] if lat else None, "max": lat[-1] if lat else None}, + "memory_MiB": {"idle": idle, "sampled_peak": peak, "after": after, + "max_growth_usage": round(max(peak[k]["usage"] - idle[k]["usage"] for k in peak), 1), + "max_growth_anon": round(max(peak[k]["anon"] - idle[k]["anon"] for k in peak), 1), + "cgroup_peak_after": {k: v["peak"] for k, v in after.items()}}, + "container_limit_MiB": 256, "samples": len(samples), + } + print(json.dumps({k: v for k, v in summary.items() if k != "samples"}, ensure_ascii=False, indent=2)) + + # Проверка, что сохранены настоящие байты (выборочно). + for x in ok[:3]: + st, raw, _ = api.raw("GET", f"/api/v1/attachments/{x['id']}/content", + headers={"Authorization": "Bearer " + u["token"]}, timeout=60) + r.check(st == 200 and sha256(raw) == digest, f"download {x['id'][:8]} sha256 matches") + r.check(len(ok) == len(results), f"all {len(results)} uploads -> 201") + r.check(summary["sha256_ok"] == len(ok), "sha256 of every upload matches") + growth = summary["memory_MiB"]["max_growth_usage"] + r.check(growth < 100, + f"peak growth per replica {growth} MiB < 100 MiB " + f"(naive buffering: ≥ {args.concurrency // 2} × {len(data) / 1024 ** 2:.1f} MiB × 2)") + if args.output: + with open(args.output, "w", encoding="utf-8") as f: + json.dump({**summary, "raw_samples": samples}, f, ensure_ascii=False, indent=2) + print("saved", args.output) + r.finish() + + +if __name__ == "__main__": + main() -- 2.54.0 From cc987efca9f21c6c9955f982626461267c5c813c Mon Sep 17 00:00:00 2001 From: LOSYASH Date: Mon, 9 Nov 2026 17:42:46 +0100 Subject: [PATCH 2/2] =?UTF-8?q?=D0=9B=D0=A04:=20username=20=D0=BF=D1=80?= =?UTF-8?q?=D0=BE=D0=B2=D0=B5=D1=80=D1=8F=D0=B5=D1=82=D1=81=D1=8F=20fullma?= =?UTF-8?q?tch,=20=D0=BF=D0=B5=D1=80=D0=B5=D0=B2=D0=BE=D0=B4=20=D1=81?= =?UTF-8?q?=D1=82=D1=80=D0=BE=D0=BA=D0=B8=20->=20400=20=D0=B2=D0=BC=D0=B5?= =?UTF-8?q?=D1=81=D1=82=D0=BE=20500?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/main.py | 6 ++++-- student-tests/run.py | 3 +++ 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/app/main.py b/app/main.py index 3d66f894..fe4c3bab 100644 --- a/app/main.py +++ b/app/main.py @@ -42,7 +42,9 @@ from .migrate import migrate logger = logging.getLogger("messenger") -USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") +# Только fullmatch: в Python "$" совпадает и перед завершающим "\n", +# поэтому match("^…$") пропустил бы "review123\n" до CHECK в БД (500). +USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}") IDEMPOTENCY_KEY_RE = re.compile(r"[A-Za-z0-9._:-]{1,128}") BEARER_CHALLENGE = 'Bearer realm="messenger"' BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' @@ -233,7 +235,7 @@ class CreateUser(BaseModel): @field_validator("username") @classmethod def check_username(cls, v: str) -> str: - if not USERNAME_RE.match(v): + if not USERNAME_RE.fullmatch(v): raise ValueError("username must match [a-z0-9_]{3,32}") return v diff --git a/student-tests/run.py b/student-tests/run.py index 312d17cb..30fb8f96 100644 --- a/student-tests/run.py +++ b/student-tests/run.py @@ -73,6 +73,9 @@ def main(): r.check(st == 400, "malformed JSON -> 400") st, _, _ = api.call("POST", "/api/v1/users", {"username": alice["username"], "display_name": "d", "password": PASSWORD}) r.check(st == 409, "duplicate username -> 409") + for bad in ("review123\n", "review123\r\n", " review123", "Review123", "ab"): + st, _, _ = api.call("POST", "/api/v1/users", {"username": bad, "display_name": "d", "password": PASSWORD}) + r.check(st == 400, f"invalid username {bad!r} -> 400, not 500 (got {st})") st, _, _ = api.call("POST", mpath, {"text": " "}, token=alice["token"]) r.check(st == 400, "blank message -> 400") st, _, _ = api.call("POST", mpath, {"text": "x", "sender_id": eve["id"]}, token=alice["token"]) -- 2.54.0