ЛР 4 — БВТ2304 — Санжаровский — на 4 #28
+29
-10
@@ -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
@@ -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
|
||||
|
||||
@@ -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
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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)"
|
||||
|
||||
@@ -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).
|
||||
|
||||
@@ -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
@@ -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()
|
||||
@@ -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
@@ -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
@@ -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
@@ -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)
|
||||
@@ -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
@@ -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()
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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")
|
||||
# Управляющие символы направления текста: «photognp.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
@@ -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:
|
||||
@@ -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]
|
||||
@@ -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]
|
||||
@@ -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]
|
||||
@@ -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]
|
||||
@@ -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]
|
||||
@@ -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]
|
||||
@@ -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]
|
||||
@@ -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]
|
||||
@@ -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
|
||||
@@ -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]
|
||||
@@ -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]
|
||||
@@ -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]
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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]
|
||||
@@ -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
|
||||
@@ -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"
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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
|
||||
@@ -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 %*
|
||||
@@ -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 "$@"
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
# Вернуть остановленные реплики API после failover-теста.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env start api
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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")
|
||||
@@ -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()
|
||||
@@ -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;
|
||||
@@ -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()
|
||||
@@ -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 |
@@ -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()
|
||||
@@ -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}
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()))
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user