ЛР 4 — БВТ2304 — Санжаровский — на 4 #28

Open
Anatoly01 wants to merge 2 commits from Anatoly01/mtusi2026lab4:solution/bvt2304-sanzharovskiy into main
70 changed files with 6627 additions and 45 deletions
+29 -10
View File
@@ -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
+43 -9
View File
@@ -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
+11
View File
@@ -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
+8 -8
View File
@@ -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, шапка.
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
+27
View File
@@ -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"]
+27 -1
View File
@@ -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)"
+145 -17
View File
@@ -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/<uuid вложения>`. `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: "<sha256>"`, `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/<id> в 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 <sha256 fixture>` в обеих репликах; `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).
View File
+22
View File
@@ -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,
)
+101
View File
@@ -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()
+50
View File
@@ -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
+235
View File
@@ -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
+177
View File
@@ -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())
+600
View File
@@ -0,0 +1,600 @@
"""
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")
# Только 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"'
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.fullmatch(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)
+57
View File
@@ -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)")
+328
View File
@@ -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()
+46
View File
@@ -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()
+168
View File
@@ -0,0 +1,168 @@
"""
Сессии: PostgreSQL — источник истины, Redis/Valkey — кэш поиска сессии.
Чтение (проверка Bearer):
1. Ищем в Redis ключ sess:<sha256(token)>. Нашли и не истёк → пользователь.
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
+211
View File
@@ -0,0 +1,211 @@
"""
Объектное хранилище (S3-совместимое, MinIO) — только БАЙТЫ вложений.
- Метаданные (кто, какой чат, sha256, размер, тип) — в PostgreSQL, источник истины.
- Ключ объекта назначает сервер: originals/<uuid>. Имя файла от клиента
в ключ не попадает (нет 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/<bucket>/<key>
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)
+167
View File
@@ -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 <attachment_id> # есть ли объект, метаданные, журнал
python -m app.tools find-local <sha256> # нет ли на диске реплики копии файла
Секреты не печатаются. Ключи объектов печатаются только для служебного 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:]))
+106
View File
@@ -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())
+251
View File
@@ -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:
+107
View File
@@ -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]
+6
View File
@@ -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]
+52
View File
@@ -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]
+15
View File
@@ -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]
+45
View File
@@ -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]
+27
View File
@@ -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]
+30
View File
@@ -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]
+21
View File
@@ -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]
+17
View File
@@ -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
+6
View File
@@ -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]
+26
View File
@@ -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]
+62
View File
@@ -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]
+378
View File
@@ -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
}
}
]
}
+599
View File
@@ -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
}
}
]
}
+156
View File
@@ -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]
+84
View File
@@ -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
+56
View File
@@ -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 <<POLICY
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
"Resource": ["arn:aws:s3:::${S3_BUCKET}/*"]
},
{
"Effect": "Allow",
"Action": ["s3:ListBucket", "s3:GetBucketLocation"],
"Resource": ["arn:aws:s3:::${S3_BUCKET}"]
}
]
}
POLICY
# create с тем же именем перезаписывает политику — повтор безопасен.
mc admin policy create root "$POLICY_NAME" /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"
+54
View File
@@ -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);
+17
View File
@@ -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);
+56
View File
@@ -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/<uuid>); уникален.
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);
+12
View File
@@ -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
+4
View File
@@ -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 %*
+7
View File
@@ -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 "$@"
+4
View File
@@ -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
+6
View File
@@ -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
+4
View File
@@ -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
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
# Вернуть остановленные реплики API после failover-теста.
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env start api
+7
View File
@@ -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
+12
View File
@@ -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
+259
View File
@@ -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"<html><script>alert(1)</script></html>", "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()
+142
View File
@@ -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()
+202
View File
@@ -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")
+49
View File
@@ -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()
+60
View File
@@ -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;
+115
View File
@@ -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()
+7
View File
@@ -0,0 +1,7 @@
# Собственные fixtures
- `sample.jpg` — синтетический JPEG 240×160 (линии и рамка), создан программно, без EXIF и персональных данных.
Остальные файлы для негативных тестов (oversized, битые, «бомба» по пикселям,
подмена MIME, шум ~9,5 МБ для эксперимента памяти) генерируются тестами
на лету (`student-tests/common.py: make_png`) — большие файлы в Git не храним.
Binary file not shown.

After

Width:  |  Height:  |  Size: 13 KiB

+91
View File
@@ -0,0 +1,91 @@
#!/usr/bin/env python3
"""
Общая идемпотентность POST сообщения через LB (lab3).
python student-tests/idempotency.py --base-url http://localhost:8080
Проверяет: параллельные запросы с ОДНИМ ключом через разные реплики дают одно
сообщение; другой body с тем же ключом → 409; ключ без/неверного формата → 400;
порядок/пробелы в JSON не важны; область ключа — пользователь + чат.
"""
import argparse
import json
import uuid
from concurrent.futures import ThreadPoolExecutor
from common import Api, Report
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default="http://localhost:8080")
ap.add_argument("--parallel", type=int, default=20)
api, r = Api(ap.parse_args().base_url), Report()
args = ap.parse_args()
alice, bob = api.new_user("idem_a"), api.new_user("idem_b")
st, chat, _ = api.call("POST", "/api/v1/chats", {"title": "idem", "member_ids": [alice["id"], bob["id"]]},
token=alice["token"])
st, chat2, _ = api.call("POST", "/api/v1/chats", {"title": "idem2", "member_ids": [alice["id"]]},
token=alice["token"])
path, path2 = f"/api/v1/chats/{chat['id']}/messages", f"/api/v1/chats/{chat2['id']}/messages"
def history(p, token):
st, page, _ = api.call("GET", p + "?limit=100", token=token)
return page["items"]
print(f"== {args.parallel} параллельных запросов с одним ключом ==")
key, text = uuid.uuid4().hex, "одно сообщение " + uuid.uuid4().hex[:6]
def send(_):
return api.call("POST", path, {"text": text}, token=alice["token"], headers={"Idempotency-Key": key})
with ThreadPoolExecutor(max_workers=args.parallel) as pool:
res = list(pool.map(send, range(args.parallel)))
codes = [x[0] for x in res]
ids = {x[1]["id"] for x in res if x[0] == 201}
instances = {x[2].get("X-Instance-Id") for x in res}
r.check(codes.count(201) == args.parallel, f"all parallel repeats -> 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()
+110
View File
@@ -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}
+68
View File
@@ -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()
+125
View File
@@ -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()
+96
View File
@@ -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()
+46
View File
@@ -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()
+52
View File
@@ -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()))
+133
View File
@@ -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()
+125
View File
@@ -0,0 +1,125 @@
#!/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")
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"])
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()
+83
View File
@@ -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()
+180
View File
@@ -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()