ЛР 4 — БВТ-2303 — Мусаев — на 4 #42
@@ -18,3 +18,19 @@ __pycache__
|
||||
node_modules
|
||||
evidence
|
||||
.DS_Store
|
||||
# в образ идут только requirements.txt, src/ и migrations/
|
||||
tests
|
||||
student-tests
|
||||
contracts
|
||||
examples
|
||||
scripts
|
||||
infra
|
||||
*.md
|
||||
Makefile
|
||||
Dockerfile*
|
||||
compose*.yaml
|
||||
lab.json
|
||||
requirements-dev.txt
|
||||
.gitignore
|
||||
.idea
|
||||
.vscode
|
||||
|
||||
+23
-1
@@ -7,10 +7,23 @@ 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:
|
||||
SESSION_STORE=postgres
|
||||
SESSION_STORE=redis
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
# info / debug / warning
|
||||
LOG_LEVEL=info
|
||||
# Сколько секунд после SIGTERM ждать незавершённые запросы (не больше 10).
|
||||
SHUTDOWN_TIMEOUT=8
|
||||
# Пул соединений с PostgreSQL и таймауты в секундах.
|
||||
DB_POOL_MIN_SIZE=2
|
||||
DB_POOL_MAX_SIZE=10
|
||||
DB_POOL_TIMEOUT=3
|
||||
DB_CONNECT_TIMEOUT=3
|
||||
DB_STATEMENT_TIMEOUT=5
|
||||
# Пул соединений с Redis и таймаут операций в секундах.
|
||||
CACHE_POOL_MAX_SIZE=20
|
||||
CACHE_TIMEOUT=2
|
||||
S3_ENDPOINT=http://s3:9000
|
||||
S3_REGION=us-east-1
|
||||
S3_BUCKET=messenger-attachments
|
||||
@@ -18,3 +31,12 @@ S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
|
||||
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
|
||||
MAX_UPLOAD_BYTES=10485760
|
||||
MAX_IMAGE_PIXELS=40000000
|
||||
# Загрузок одновременно на одну реплику и время на приём одного файла в секундах.
|
||||
MAX_PARALLEL_UPLOADS=32
|
||||
UPLOAD_TIMEOUT_SECONDS=60
|
||||
# Записей в S3 одновременно с одной реплики и ожидание очереди в секундах.
|
||||
S3_PARALLEL_WRITES=4
|
||||
S3_WRITE_QUEUE_SECONDS=10
|
||||
# Возраст брошенной загрузки и период проходов janitor в секундах.
|
||||
ATTACHMENT_GRACE_SECONDS=3600
|
||||
JANITOR_INTERVAL_SECONDS=300
|
||||
|
||||
+37
@@ -0,0 +1,37 @@
|
||||
FROM python:3.13.16-slim-bookworm
|
||||
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
PIP_DISABLE_PIP_VERSION_CHECK=1
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
# сначала зависимости: слой переиспользуется, пока не меняется requirements.txt
|
||||
COPY requirements.txt .
|
||||
RUN pip install -r requirements.txt
|
||||
|
||||
RUN groupadd --system --gid 10001 app \
|
||||
&& useradd --system --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app
|
||||
|
||||
COPY src/ .
|
||||
COPY migrations/ migrations/
|
||||
|
||||
USER 10001:10001
|
||||
|
||||
ARG APP_VERSION=dev
|
||||
|
||||
ENV APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080 \
|
||||
APP_ENV=lab \
|
||||
APP_VERSION=$APP_VERSION
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=5s --timeout=4s --start-period=20s --start-interval=1s --retries=3 \
|
||||
CMD ["python", "healthcheck.py"]
|
||||
|
||||
STOPSIGNAL SIGTERM
|
||||
|
||||
# exec-форма: python запускается как PID 1 и сам получает SIGTERM
|
||||
CMD ["python", "main.py"]
|
||||
@@ -2,9 +2,11 @@ PYTHON ?= python3
|
||||
BASE_URL ?= http://localhost:8080
|
||||
CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
COMPOSE = docker compose --env-file .env
|
||||
COMPOSE_TEST = $(COMPOSE) -f compose.yaml -f compose.test.yaml
|
||||
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 env up down clean restore student-test test-failures explain failover-each failover-hard rolling-update janitor upload-peak attachment-demo test-images
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@@ -28,3 +30,62 @@ 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)
|
||||
|
||||
env:
|
||||
./scripts/init-env.sh
|
||||
|
||||
up: env
|
||||
$(COMPOSE) up -d --build
|
||||
BASE_URL="$(BASE_URL)" ./scripts/wait-ready.sh
|
||||
|
||||
down:
|
||||
$(COMPOSE_TEST) down
|
||||
|
||||
# удаляет контейнеры вместе с данными PostgreSQL и Redis
|
||||
clean:
|
||||
$(COMPOSE_TEST) down -v
|
||||
|
||||
# возвращает реплики, остановленные scripts/stop-one.sh
|
||||
restore:
|
||||
$(COMPOSE) up -d --no-recreate --no-build api
|
||||
BASE_URL="$(BASE_URL)" ./scripts/wait-ready.sh
|
||||
|
||||
student-test:
|
||||
BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests -v
|
||||
|
||||
# останавливает и запускает redis/postgres, поднимает отдельный API на порту 8081
|
||||
test-failures:
|
||||
BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests/failures -v
|
||||
|
||||
explain:
|
||||
./scripts/explain_history.sh
|
||||
|
||||
# по очереди останавливает каждую реплику под нагрузкой
|
||||
failover-each:
|
||||
BASE_URL="$(BASE_URL)" $(PYTHON) scripts/chaos.py stop --output evidence/failover-each.json
|
||||
|
||||
# то же с SIGKILL и с зависшей репликой (docker pause)
|
||||
failover-hard:
|
||||
BASE_URL="$(BASE_URL)" $(PYTHON) scripts/chaos.py kill --output evidence/failover-kill.json
|
||||
BASE_URL="$(BASE_URL)" $(PYTHON) scripts/chaos.py pause --output evidence/failover-pause.json
|
||||
|
||||
# заменяет реплики новым образом под нагрузкой: make rolling-update APP_VERSION=2
|
||||
rolling-update:
|
||||
BASE_URL="$(BASE_URL)" $(PYTHON) scripts/chaos.py rolling --output evidence/rolling-update.json
|
||||
|
||||
# один проход очистки; реплики и сервис janitor не затрагиваются
|
||||
janitor:
|
||||
$(COMPOSE) run --rm --no-deps janitor python janitor.py --once
|
||||
|
||||
# 10 одновременных загрузок по 10 MiB с замером пика памяти реплик
|
||||
upload-peak:
|
||||
BASE_URL="$(BASE_URL)" $(PYTHON) scripts/upload_peak.py --output evidence/upload-peak.json
|
||||
|
||||
# сценарий защиты: файл, сообщение, второй участник, посторонний, прямой GET в S3
|
||||
attachment-demo:
|
||||
$(PYTHON) scripts/attachment_demo.py
|
||||
|
||||
# разбор изображений и сверка с Pillow внутри образа API: там установлен декодер
|
||||
test-images:
|
||||
COPYFILE_DISABLE=1 tar -cf - src/images.py student-tests/samples.py student-tests/image tests/fixtures/sample.png | \
|
||||
docker run --rm -i --entrypoint sh mtusi-messenger:lab4 -c 'cd /tmp && tar -xf - && python -m unittest discover -s student-tests/image -v'
|
||||
|
||||
@@ -1,37 +1,290 @@
|
||||
# Отчёт — лабораторная 4
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Мусаев Абдул-Хамид Рамзанович, БВТ-2303
|
||||
- Целевая оценка; выбранный трек 5, если нужен: 4, трек 5 не заявлен
|
||||
- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab4/pulls/42
|
||||
- Использованные источники, библиотеки и помощь ИИ:
|
||||
- библиотеки и образы: FastAPI 0.143.0, Uvicorn 0.54.0, psycopg 3.3.6, redis-py 8.1.0, argon2-cffi 25.1.0, boto3 1.43.122, Pillow 13.0.0, HAProxy 3.2.26, PostgreSQL 17.11, Redis 7.4.11, SeaweedFS 4.50 (полный список в `requirements.txt`, `compose.yaml`, `infra/`);
|
||||
- источники: документация SeaweedFS (S3 API, конфигурация ключей), AWS S3 и boto3, спецификации PNG и JPEG (структура блоков и маркеров), `contracts/README.md`;
|
||||
- помощь ИИ: ИИ-ассистент использовался во вспомогательных целях.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Нужны Docker с Compose v2 (проверено на Docker 29.3.0, Compose 5.1.0), `make`, `openssl`, `curl` и Python 3.9+ на хосте для тестов.
|
||||
|
||||
```sh
|
||||
make up # создаёт .env с паролями и ключами, собирает образы, поднимает стенд и ждёт /health/ready
|
||||
|
||||
make check # структура skeleton
|
||||
make test # публичный smoke
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
make restore # вернуть реплику, остановленную failover-тестом
|
||||
|
||||
make attachment-demo # сценарий защиты: файл, сообщение, посторонний, прямой GET в S3
|
||||
make student-test # тесты API и вложений
|
||||
make test-images # разбор изображений и сверка с Pillow внутри образа API
|
||||
make test-failures # сбой между S3 и БД, отказ S3, приватность bucket, отказ Redis и PostgreSQL
|
||||
make upload-peak # 1, 10 и 30 загрузок по 10 MiB и 10 самых тяжёлых JPEG с замером памяти
|
||||
make janitor # один проход очистки вручную
|
||||
make failover-each # остановка каждой реплики под нагрузкой
|
||||
make rolling-update APP_VERSION=2
|
||||
make explain # синтетическая история и планы запросов
|
||||
|
||||
make down # остановить контейнеры, данные остаются в volumes
|
||||
make clean # то же и удалить volumes: намеренное удаление учебных данных
|
||||
```
|
||||
|
||||
Bucket и миграции отдельных команд не требуют: при `up` одноразовые контейнеры `s3-init` и `migrate` выполняются до старта реплик.
|
||||
|
||||
`make test-failures` сам останавливает и запускает `redis`, `postgres`, `s3` и удаляет синтетические объекты, поэтому запускать его нужно только на учебном стенде. Прогон занимает около 5 минут.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
edge data (internal)
|
||||
клиент ──> lb (HAProxy) ──┬──> api-1 ──┬──> postgres: метаданные, сообщения, ключи идемпотентности
|
||||
127.0.0.1:8080 └──> api-2 ──┼──> redis: сессии
|
||||
│
|
||||
│ storage (internal)
|
||||
└──> s3 (SeaweedFS): байты вложений, приватный bucket
|
||||
▲
|
||||
janitor ──────────┘ также data: очистка незавершённых загрузок
|
||||
|
||||
s3-init, migrate: одноразовые контейнеры до старта реплик
|
||||
```
|
||||
|
||||
### Роли и сервисы
|
||||
|
||||
| Роль | Сервис | Образ | Готовность | Volume | Сеть и порт | Лимиты | Секреты |
|
||||
| --- | --- | --- | --- | --- | --- | --- | --- |
|
||||
| load_balancer | `lb` | `infra/haproxy` на `haproxy:3.2.26-alpine` | `/lb-health` | нет | `edge`, опубликован только `127.0.0.1:8080` | 0,5 CPU, 128 МБ | нет |
|
||||
| api | `api`, 2 реплики | `Dockerfile` на `python:3.13.16-slim-bookworm` | `/health/ready` | нет, состояния не хранит | `edge`, `data`, `storage`, порт не опубликован | 1 CPU, 512 МБ | БД, Redis, S3-ключ API |
|
||||
| очистка | `janitor` | тот же образ | нет, цикл с логом | нет | `data`, `storage` | 0,25 CPU, 128 МБ | БД, S3-ключ janitor |
|
||||
| bootstrap | `migrate`, `s3-init` | тот же образ | одноразовые, код выхода 0 | нет | `data`; `storage` | 0,5 CPU, 128 МБ | БД; S3-ключ admin |
|
||||
| s3 | `s3` | `infra/s3` на `chrislusf/seaweedfs:4.50` | том данных зарегистрирован в мастере и S3 отвечает | `s3data` | `storage`, порт 9000 не опубликован | 1 CPU, 1 ГБ | все три S3-ключа |
|
||||
| postgres | `postgres` | `postgres:17.11-alpine` | `pg_isready` | `pgdata` | `data` | 1 CPU, 512 МБ | пароль файлом |
|
||||
| redis | `redis` | `redis:7.4.11-alpine` | `redis-cli ping` | `redisdata` | `data` | 0,5 CPU, 128 МБ | пароль файлом |
|
||||
|
||||
Секреты описаны как `secrets` с источником из `.env` и попадают в контейнеры файлами в `/run/secrets`. Ключа администратора S3 у API нет (`evidence/10-containers.txt`).
|
||||
|
||||
**Почему SeaweedFS.** В задании на выбор MinIO, SeaweedFS или RustFS. Образы `minio/minio` и `minio/mc` на этом стенде из реестра не скачались («repository does not exist»), а зависеть от локального кэша нельзя: стенд должен собираться из чистого clone. У SeaweedFS права ключей задаются обычным JSON, отдельный административный клиент не нужен.
|
||||
|
||||
### Модель данных и запись файла
|
||||
|
||||
Таблица `attachments`: чат, владелец, отображаемое имя, тип, размер, sha256, `object_key`, `state`. Таблица `message_attachments`: связь сообщения с вложениями и их порядок. Одно вложение можно прикрепить к нескольким сообщениям, контракт это допускает. Ключ объекта — `originals/<uuid>`, его назначает сервер; имя файла в нём не участвует и используется только для показа. В S3 не передаётся ни имя файла, ни id пользователя.
|
||||
|
||||
Загрузка в `POST /api/v1/chats/{id}/attachments`:
|
||||
|
||||
1. Проверки до чтения тела: токен → членство в чате (посторонний 404) → имя файла → `Content-Type` → `Content-Length` → лимит параллельных загрузок.
|
||||
2. Тело пишется блоками во временный файл без имени, считается размер и sha256. Превышение 10 MiB обрывает приём сразу.
|
||||
3. Содержимое проверяется в `src/images.py`, после чего загрузка ждёт очереди на запись в S3.
|
||||
4. **Запись в три шага:** строка `pending` в PostgreSQL (COMMIT) → PUT в S3 → `UPDATE ... state = 'ready'` (COMMIT).
|
||||
5. Только после этого ответ 201 `status=ready`.
|
||||
|
||||
Статус `pending` внутренний: такое вложение нельзя получить через API и прикрепить к сообщению, контракт видит только `ready`.
|
||||
|
||||
### Что если S3 PUT прошёл, а COMMIT нет
|
||||
|
||||
Главное решение: **строка в БД появляется раньше объекта.** Поэтому в S3 не может появиться объект, о котором БД ничего не знает, а любой сбой оставляет понятное состояние.
|
||||
|
||||
| Где произошёл сбой | Что осталось | Что видит клиент | Что происходит дальше |
|
||||
| --- | --- | --- | --- |
|
||||
| обрыв клиента при приёме файла | ничего: временный файл удаляется, S3 и БД не тронуты | соединение оборвано | ничего не нужно |
|
||||
| БД недоступна до записи строки | ничего | 503 | ничего не нужно |
|
||||
| PUT в S3 не прошёл | строка `pending` | 503 | janitor удаляет строку после grace period |
|
||||
| PUT прошёл, подтверждение не прошло | строка `pending` и объект | 503 | janitor удаляет объект, затем строку |
|
||||
| реплика упала посреди записи | то же | ошибка от балансировщика | то же |
|
||||
|
||||
**Механизм очистки** — сервис `janitor` (`src/janitor.py`), свой S3-ключ, проход раз в 5 минут:
|
||||
|
||||
1. Строки `pending` старше grace period: сначала удаляется объект, потом строка. Если упасть посередине, следующий проход повторит то же самое; удаление отсутствующего объекта безопасно.
|
||||
2. Сверка: объекты старше grace period без строки в БД удаляются. Обычно таких нет, это защита от потери строки, например при восстановлении БД из старой копии. Сверка идёт постранично.
|
||||
|
||||
**Grace period** — 1 час (`ATTACHMENT_GRACE_SECONDS`), он намного больше самой долгой загрузки: приём файла не больше 60 с, очередь 10 с, S3 7 с. Свежая незавершённая загрузка этим не затрагивается, вложения `ready` не удаляются никогда. Если очень медленная загрузка всё же проснётся после очистки, `UPDATE` не найдёт строку, и клиент получит 503, а не ложный 201.
|
||||
|
||||
`--dry-run` только считает, `--grace-seconds` меняет порог для проверок.
|
||||
|
||||
### Потоковая обработка и лимиты
|
||||
|
||||
| Ограничение | Значение | Что будет при превышении |
|
||||
| --- | --- | --- |
|
||||
| размер файла | 10 MiB (`MAX_UPLOAD_BYTES`) | 413; по `Content-Length` сразу, без него на ходу приёма |
|
||||
| грубый предел на балансировщике | 11 MiB | 413 до API |
|
||||
| пиксели | 40 млн (`MAX_IMAGE_PIXELS`) | 413 из заголовка, без распаковки |
|
||||
| сканов в JPEG | 100 | 415: каждый скан заставляет декодер пройти всё изображение, в 10 MiB их поместились бы тысячи |
|
||||
| декодирований JPEG на реплику | 1 | следующее ждёт, память не складывается |
|
||||
| тело JSON-запроса | 1 MiB | 413 |
|
||||
| время приёма файла | 60 с | 400 |
|
||||
| загрузок на реплику | 32 | 429 с `Retry-After` |
|
||||
| одновременных записей в S3 с реплики | 4 | ждёт очереди до 10 с, затем 503 |
|
||||
| соединение / чтение S3 | 2 с / 5 с, без повторов | 503 |
|
||||
|
||||
В памяти одновременно находится только текущий блок: тело читается потоком, файл уходит в S3 из временного файла, скачивание отдаётся блоками по 64 КБ.
|
||||
|
||||
**Проверка изображения (`src/images.py`).** Размер берётся из заголовка до любой работы с данными, поэтому decompression bomb отсекается сразу. Настоящий тип должен совпасть с `Content-Type`, иначе 415.
|
||||
|
||||
*PNG* проверяется потоково, память не зависит от размера изображения: сигнатура, порядок блоков (IHDR первым, IDAT подряд, PLTE до данных и обязателен для палитры, неизвестные обязательные блоки запрещены), CRC каждого блока, распаковка с выбрасыванием результата, байт фильтра 0–4 в начале каждой строки, точный объём данных, в том числе для чересстрочных изображений Adam7, запрет данных после конца.
|
||||
|
||||
*JPEG* так проверить нельзя: понять, что в скане настоящие данные, можно только декодированием. Поэтому сначала идёт быстрый разбор маркеров (размер, заголовок кадра, число сканов, объём данных не меньше 1 бита на блок), затем настоящий декодер Pillow с уменьшением в 8 раз. Файл принимается, только если декодер дошёл до конца. Обычный JPEG при этом занимает около 6 МБ. Прогрессивный хранит коэффициенты всего изображения, уменьшение тут не помогает: измерено 234 МБ для RGB и 311 МБ для CMYK на 40 млн пикселей. Поэтому декодирование идёт по одному на реплику, а лимит реплики поднят до 512 МБ.
|
||||
|
||||
Почему PNG не отдан Pillow целиком: 40 млн пикселей RGBA заняли бы 160 МБ, а уменьшения при чтении у PNG нет. Соответствие декодеру проверяется отдельно, см. раздел об экспериментах.
|
||||
|
||||
**Имя файла.** 1–255 символов Unicode, запрещены `/`, `\`, NUL, управляющие символы, символы смены направления текста (ими маскируют расширение), строки из пробелов, `.` и `..`.
|
||||
|
||||
### Доступ и приватность
|
||||
|
||||
Bucket приватный: в конфигурации сервера нет анонимного пользователя, запрос без подписи получает 403. Скачивание идёт только через API, без redirect. Каждый запрос проверяет членство в чате; посторонний получает тот же 404, что и при несуществующем вложении. Случайный ключ и приватность bucket этой проверки не заменяют: они защищают от доступа в обход API, но не решают, кому из пользователей можно видеть файл.
|
||||
|
||||
| Ключ S3 | Кто использует | Права | Проверено |
|
||||
| --- | --- | --- | --- |
|
||||
| `admin` | `s3-init` | всё | используется только при создании bucket |
|
||||
| `api` | реплики | чтение и запись объектов этого bucket | список объектов, создание и удаление bucket — AccessDenied |
|
||||
| `janitor` | очистка | список и запись (удаление) объектов этого bucket | чтение не выдано |
|
||||
|
||||
Ограничение SeaweedFS: право `Write` включает удаление объекта, поэтому ключ API может удалить объект, зная его ключ. Полностью разделить «запись» и «удаление» этими средствами не удалось.
|
||||
|
||||
Административного интерфейса наружу нет: порты `s3` не опубликованы, сеть `storage` внутренняя, в ней только `s3`, API, `janitor` и `s3-init`. Веб-страница мастера SeaweedFS (9333) доступна только внутри этой сети.
|
||||
|
||||
### Отказ S3 и готовность
|
||||
|
||||
`/health/ready` **не проверяет S3 намеренно**: текст, история и метаданные работают без него. Если бы реплики становились неготовыми, отказ S3 остановил бы весь мессенджер. При недоступном S3 загрузка и скачивание дают 503, остальное работает (`test_s3_down`).
|
||||
|
||||
Готовность самого контейнера `s3` проверяет регистрацию тома в мастере. Порт S3 открывается раньше, а до этого запросы к объектам зависают. После перезапуска на это уходит 20–30 с, `scripts/restart.sh` ждёт. На пустом хранилище первая запись запускает создание томов дольше таймаута API, поэтому `s3-init` делает пробную запись, чтение и удаление, и реплики стартуют только после неё.
|
||||
|
||||
### Идемпотентность с вложениями
|
||||
|
||||
Ключ, сообщение и ссылки на вложения пишутся одной транзакцией. Проверка вложений (готово и лежит в этом чате) выполняется в ней же: чужое или неизвестное вложение даёт 404 и откатывает занятие ключа, поэтому ключ можно использовать снова. Повтор сравнивается по тексту и списку `attachment_ids`; отсутствующий список равен пустому, другой список — 409.
|
||||
|
||||
### Исправления по замечаниям
|
||||
|
||||
**Неполная проверка корректности изображения.** PNG 1×1 с верными CRC и строкой с недопустимым фильтром `ff`, а также JPEG из 27 байт только с заголовками принимались как `ready`: первая версия проверяла форму файла, но не его содержимое. Теперь PNG проверяется построчно, JPEG проходит через настоящий декодер (раздел о проверке изображения выше). Оба файла из замечания дают 415, тесты: `test_files_from_review`, `ReviewCasesTest`. Чтобы не исправлять только два примера, добавлена сверка с Pillow на 11 580 испорченных файлах.
|
||||
|
||||
### Что перенесено из lab3 и что изменено
|
||||
|
||||
Перенесены: балансировщик и реплики, сессии в Redis, идемпотентность, миграции, поочерёдная замена, строгий разбор JSON, все тесты. Добавлены: сервисы `s3`, `s3-init`, `janitor`, сеть `storage`, миграция `0003`, endpoint вложений, поле `attachment_ids`. Изменено: `timeout server` балансировщика 20 с вместо 12; строгие лимиты тела JSON (раньше лимита не было). Миграция `0003` снимает требование непустого текста и добавляет таблицы, версия lab3 на такой схеме продолжила бы работать; совместная работа разных версий не проверялась.
|
||||
|
||||
### Соответствие переменных окружения
|
||||
|
||||
| Переменная | По умолчанию | Что делает |
|
||||
| --- | --- | --- |
|
||||
| `S3_ENDPOINT`, `S3_REGION`, `S3_BUCKET` | `http://s3:9000`, `us-east-1`, `messenger-attachments` | адрес и bucket; endpoint в compose задан жёстко |
|
||||
| `S3_ACCESS_KEY_ID_FILE`, `S3_SECRET_ACCESS_KEY_FILE` | `/run/secrets/...` | ключ API |
|
||||
| `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS` | `10485760`, `40000000` | лимиты контракта |
|
||||
| `MAX_PARALLEL_UPLOADS`, `UPLOAD_TIMEOUT_SECONDS` | `32`, `60` | загрузок на реплику, время приёма |
|
||||
| `S3_PARALLEL_WRITES`, `S3_WRITE_QUEUE_SECONDS` | `4`, `10` | записей в S3 с реплики, ожидание очереди |
|
||||
| `ATTACHMENT_GRACE_SECONDS`, `JANITOR_INTERVAL_SECONDS` | `3600`, `300` | возраст брошенной загрузки, период проходов |
|
||||
| `S3_ADMIN_*`, `S3_ACCESS_KEY_ID`, `S3_SECRET_ACCESS_KEY`, `S3_JANITOR_*` | создаёт `init-env.sh` | источник compose-секретов |
|
||||
| остальные | см. `.env.example` | как в lab3 |
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
Стенд: Apple M3 Pro, 11 CPU, 18 ГБ RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0. Лимиты контейнеров в таблице ролей. Все файлы получены из чистого clone на пустых volumes; код в них совпадает с коммитом этого PR.
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Публичный smoke сразу после чистого запуска | `make up`, `make test` | `PASS: lab4 public API scenario` | `evidence/01-up-and-smoke.txt` |
|
||||
| 3: S3 в общем стенде, метаданные в PostgreSQL, байты в приватном bucket | `make up`, `make attachment-demo` | сервис `s3`, прямой GET без подписи 403 | `evidence/01-up-and-smoke.txt`, `evidence/02-defense-scenario.txt` |
|
||||
| 3: 201 ready, побайтное скачивание, сообщение с вложением, посторонний 404 | `make attachment-demo`, `test_attachments.py` | sha256 совпал, посторонний 404 на метаданные и байты | `evidence/02-defense-scenario.txt`, `evidence/03-student-tests.txt` |
|
||||
| 3: PNG/JPEG ≤10 MiB и ≤40 млн пикселей, проверка по содержимому, опасные имена | `test_attachments.py`, `make test-images` | ровно 10 MiB — 201, на байт больше — 413; bomb — 413; подмена — 415; 0 файлов принято вопреки Pillow | `evidence/03-student-tests.txt`, `evidence/03-image-tests.txt` |
|
||||
| 3: upload → остановка реплики → download через другую | `make test-failover`, 2 прогона | `PASS`, контейнер `exited`, файл скачан и совпал | `evidence/05-failover-public.txt` |
|
||||
| 3: restart сохраняет метаданные и оригинал | `make test-persistence` | `PASS`, новое время старта у всех контейнеров, включая `s3` | `evidence/04-persistence.txt` |
|
||||
| 4: большой файл, повреждённое изображение, подмена MIME, чужой id, файл другого чата | `test_attachments.py`, `make test-images` | 413, 415, 415, 404, 404; ни одного 500 | `evidence/03-student-tests.txt`, `evidence/03-image-tests.txt` |
|
||||
| 4: прерывание загрузки и отказ между S3 и БД | `test_storage.py`, настоящий `kill` PostgreSQL при 12 потоках загрузки | 8 объектов остались в S3 без подтверждения; после очистки S3 и БД совпадают, 3 подтверждённых файла скачиваются | `evidence/08-failures.txt` |
|
||||
| 4: grace period и безопасность очистки | `test_grace_period_protects_fresh_upload`, `test_ready_attachments_are_never_removed` | свежий `pending` и `ready` не тронуты | `evidence/08-failures.txt` |
|
||||
| 4: лимиты, потоковая обработка, ≥10 одновременных загрузок, пик памяти | `make upload-peak`, 5 прогонов | см. таблицу ниже, OOM 0 у S3 и реплик | `evidence/09-upload-memory.txt`, `evidence/upload-peak.json` |
|
||||
| 4: bootstrap идемпотентен | `docker compose run --rm s3-init` | `bucket уже есть`, объекты не изменились | `evidence/04-persistence.txt`, `evidence/08-failures.txt` |
|
||||
| 4: отдельный S3-ключ с ограниченными правами | `test_bucket_is_private_and_api_key_is_limited` | list, create, delete bucket — AccessDenied | `evidence/08-failures.txt` |
|
||||
| 4: консоль не открыта, проверка private bucket вне API | `docker compose ps`, тот же тест | порты `s3` не опубликованы, анонимный GET 403 | `evidence/10-containers.txt`, `evidence/08-failures.txt` |
|
||||
| Отказ S3 | `test_s3_down`, `test_failed_upload_is_cleaned` | 503 на файлах, текст и готовность работают, `pending` убран | `evidence/08-failures.txt` |
|
||||
| Возможности lab3: failover, поочерёдная замена | `make failover-each`, `make rolling-update` | см. таблицу ниже | `evidence/06-failover-each.txt`, `evidence/07-rolling-update.txt` |
|
||||
| Возможности lab2 и lab1: истечение, отказы, индекс, SIGTERM | `make test-failures`, `make explain`, `sigterm_check.py` | тесты `ok`, Index Scan, выход за 1,57 с | `evidence/08-failures.txt`, `evidence/12-explain.txt`, `evidence/11-sigterm.txt` |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
Собственные тесты: 127 в `make student-test` (40 про вложения), 40 в `make test-images` и 27 в `make test-failures` (12 про хранение).
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
### Проверка изображений против настоящего декодера
|
||||
|
||||
Гипотеза: файл, который декодер отвергает, не проходит и наш разбор. Методика (`student-tests/image/test_against_pillow.py`, запуск в образе API): Pillow загружает файл полностью и без уменьшения и служит судьёй. Все файлы, которые он умеет записать (PNG 1/L/LA/P/RGB/RGBA/16 бит, JPEG gray/RGB/CMYK, все виды прореживания, прогрессивный, с маркерами рестарта, 1×1), должны приниматься. Испорченные должны отвергаться, если их отвергает Pillow.
|
||||
|
||||
| Набор | Файлов | Принято нами | Принято вопреки Pillow |
|
||||
| --- | --- | --- | --- |
|
||||
| случайная замена байтов | 6200 | 2218 | 0 |
|
||||
| обрезка, в том числе с дописанным маркером конца | 2480 | 370 | 0 |
|
||||
| PNG с верными CRC и случайными данными | 1500 | 1354 | 0 |
|
||||
| JPEG с настоящими заголовками и случайным сканом | 800 | 792 | 0 |
|
||||
| случайный порядок блоков PNG | 600 | 0 | 0 |
|
||||
|
||||
Ограничение: Pillow здесь судья и для JPEG, и libjpeg терпим к мусору в сжатых данных. Поэтому 792 файла из 800 в четвёртой строке приняты: случайные байты декодер читает как шум. Обнаружить такое можно только анализом самого изображения.
|
||||
|
||||
### Память при одновременных загрузках
|
||||
|
||||
Гипотеза: при потоковой обработке пик памяти процесса почти не зависит от числа загрузок, а самый тяжёлый JPEG укладывается в лимит реплики. Методика (`scripts/upload_peak.py`): реплики перезапускаются, затем идут 1, 10 и 30 одновременных загрузок через балансировщик настоящего PNG 10 481 664 байт и 10 загрузок прогрессивного CMYK JPEG на 40 млн пикселей (2,6 МиБ). Измеряется `VmHWM` процесса (пик RSS) на обеих репликах. 5 прогонов подряд.
|
||||
|
||||
| Файл | Параллельно | Время, с (мин–макс) | Успешных | Пик RSS реплики, МиБ |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| — (после старта) | 0 | — | — | 117 |
|
||||
| PNG 10 MiB | 1 | 0,14–0,17 | 5 из 5 | 117–119 |
|
||||
| PNG 10 MiB | 10 | 1,34–2,10 | 50 из 50 | 124–127 |
|
||||
| PNG 10 MiB | 30 | 4,89–7,19 | 150 из 150 | 127–131 |
|
||||
| прогрессивный JPEG, 40 млн пикселей | 10 | 1,31–1,47 | 50 из 50 | 435–440 |
|
||||
|
||||
Вывод: 30 файлов общим объёмом 300 МиБ добавили к пику примерно 13 МиБ. Наивная версия, держащая файлы в памяти, потребовала бы около 150 МиБ на реплику сверх базовых 117. Десять самых тяжёлых JPEG дают пик одного декодирования, а не десяти, это подтверждает работу ограничения: иначе реплика ушла бы за лимит 512 МБ.
|
||||
|
||||
Ограничение измерения: `memory.peak` контейнера выше RSS на PNG-уровнях, в него входит кэш страниц временных файлов, который система освобождает. OOM не было ни у S3, ни у реплик, перезапусков тоже. Разброс времени велик: S3 и генератор нагрузки работают на одном компьютере.
|
||||
|
||||
### Что эксперимент нашёл по дороге
|
||||
|
||||
- **Первая версия замера была недействительна.** Генератор PNG сжимал повторяющиеся строки, файлы оказались по 72 КБ вместо 10 МиБ. Заметил по полю `file_bytes`. Теперь пиксели случайные, а размер проверяется тестом.
|
||||
- **S3 падал под нагрузкой.** С настоящими файлами 30 параллельных загрузок дали 503, причём нестабильно: то проходили, то нет. Причины две. Сначала S3 не успевал за таймаут, поэтому появилась очередь записи вместо увеличения таймаута. Затем выяснилось, что контейнер убивается OOM killer при лимите 512 МБ (`die exit=137`). Лимит поднят до 1 ГБ, Go получил мягкий предел `GOMEMLIMIT`. Поэтому прогонов 5, а не 1.
|
||||
- **Первая загрузка на пустом стенде падала с 503**, это нашёл только прогон из чистого clone. Описано в разделе про готовность.
|
||||
|
||||
### Сбой между S3 и БД
|
||||
|
||||
Гипотеза: при любом сбое после очистки множество объектов S3 совпадает со строками `ready`, а подтверждённые файлы целы. Методика (`test_postgres_lost_during_parallel_uploads`): 12 потоков загружают файлы по 3 МиБ, через 0,25 с PostgreSQL убивается (`docker compose kill`), затем запускается, выполняется проход janitor. Результат: подтверждено 3 файла, 8 объектов осталось в S3 без подтверждения, после очистки расхождений нет, подтверждённые файлы скачиваются с верным sha256. Состав окна зависит от момента сбоя, поэтому 3 подтверждения делаются заранее: проверка сохранности не может оказаться пустой.
|
||||
|
||||
### Остальные отказы
|
||||
|
||||
Нагрузка `scripts/chaos.py` та же, что в lab3: 4 клиента пишут текстовые сообщения, неопределённый результат повторяется с тем же ключом.
|
||||
|
||||
| Воздействие | Реплика | Длительность, с | Успешных | RPS | Ошибок | Исключена LB через, с | Пауза записи, с | Потери / дубли |
|
||||
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
|
||||
| `docker stop` | 1 | 18,19 | 8 333 | 458 | 0 | 1,63 | 1,00 | 0 / 0 |
|
||||
| `docker stop` | 2 | 19,85 | 9 258 | 466 | 1 (502) | 0,78 | 1,02 | 0 / 0 |
|
||||
| rolling update, 14,8 с | обе | 24,77 | 13 125 | 530 | 0 | — | 1,00 | 0 / 0 |
|
||||
|
||||
Единственная ошибка 502 закрыта повтором клиента с тем же ключом, как и в lab3.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| upload, остановка реплики, download | файл доступен через другую реплику | `PASS`, запись восстановилась за 1,7–2,1 с | потерь нет |
|
||||
| `docker compose restart` всего стенда | данные, сессия и файл на месте | `PASS`, прежний токен скачал прежний файл | 20–30 с на S3, потерь нет |
|
||||
| `docker compose stop s3` | файлы 503, остальное работает | загрузка и скачивание 503, текст 201, `/health/ready` 200 | 20–30 с после запуска |
|
||||
| `kill postgres` при загрузках | неподтверждённое убрано, подтверждённое цело | см. выше | очистка при следующем проходе после grace period |
|
||||
| обрыв 4 загрузок клиентом | ничего не остаётся | S3 и `attachments` не изменились | — |
|
||||
|
||||
Индекс истории (`make explain`, 91 163 сообщения, 10 000 в чате). К истории добавился подзапрос `attachment_ids`, это 1 буфер на сообщение, поэтому числа выше, чем в lab3, но характер тот же:
|
||||
|
||||
| Запрос | Буферов | Время |
|
||||
| --- | --- | --- |
|
||||
| первая страница | 64 | 0,286 мс |
|
||||
| страница после 5000-го сообщения, keyset | 59 | 0,291 мс |
|
||||
| та же страница через OFFSET | 5551 | 6,266 мс |
|
||||
| keyset без индекса | 1322 | 3,455 мс |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- **Не выдерживается** отказ `lb`, `postgres`, `redis`, `s3` или хоста: всё в одном экземпляре на одном Docker-хосте. У S3 один том без репликации, потеря `s3data` означает потерю файлов. Резервных копий нет.
|
||||
- JPEG с мусором внутри сжатых данных принимается, если настоящий декодер читает его как изображение: libjpeg считает это шумом, а не ошибкой. У PNG проверяются все данные, но смысл пикселей тоже не оценивается.
|
||||
- Декодирование одного тяжёлого JPEG занимает до 330 МБ на реплику, поэтому лимит реплики 512 МБ. Они идут по одному, очередь создаёт задержку при массовой загрузке прогрессивных файлов.
|
||||
- Ключ API может удалять объекты (ограничение прав SeaweedFS).
|
||||
- Вложение `ready`, не прикреплённое ни к одному сообщению, хранится бессрочно: контракт разрешает прикрепить его позже, а механизма удаления в API нет.
|
||||
- Сверка находит лишние объекты, но не обратный случай: строка `ready`, а объект потерян. Такое скачивание даст 503, автоматического обнаружения нет.
|
||||
- На диске реплики временно может лежать до 32 файлов по 10 MiB, файлы не шифруются и исчезают после обработки. Это не хранилище: реплика не нужна для чтения файла.
|
||||
- При нагрузке выше пропускной способности S3 загрузки получают 503 после 10 с очереди. Предел в числах не измерялся.
|
||||
- Записи `idempotency_keys` с истёкшим сроком не очищаются.
|
||||
- SeaweedFS пишет предупреждение о gRPC IAM без аутентификации на filer: порт доступен только внутри сети `storage`.
|
||||
- Ответ при `Content-Length` больше лимита приходит сразу, клиент может не успеть его прочитать, если продолжает отправку: это обычное поведение HTTP.
|
||||
- `X-Instance-Id` раскрывает короткий id контейнера. В lab7 нужен alias.
|
||||
- Проверено на одном стенде (macOS, Docker Desktop). На Linux не запускалось. Генератор нагрузки работал на том же компьютере, замеры дают порядок величин, а не предел стенда.
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
# Только для тестов срока жизни: отдельный API с короткими TTL, опубликованный на 8081.
|
||||
# В основной стенд не входит, там API доступен только через балансировщик.
|
||||
services:
|
||||
api-short-ttl:
|
||||
extends:
|
||||
file: compose.yaml
|
||||
service: api
|
||||
environment:
|
||||
SESSION_TTL_SECONDS: "2"
|
||||
IDEMPOTENCY_TTL_SECONDS: "2"
|
||||
ports:
|
||||
- "127.0.0.1:8081:8080"
|
||||
deploy:
|
||||
replicas: 1
|
||||
+301
@@ -0,0 +1,301 @@
|
||||
name: mtusi-messenger-lab4
|
||||
|
||||
# Настройки и секреты берутся из .env (создаёт scripts/init-env.sh, в Git не попадает).
|
||||
# Секреты доходят до контейнеров только файлами в /run/secrets, в переменных окружения контейнеров их нет.
|
||||
|
||||
x-app: &app
|
||||
build:
|
||||
context: .
|
||||
args:
|
||||
APP_VERSION: ${APP_VERSION:-dev}
|
||||
image: mtusi-messenger:lab4
|
||||
|
||||
x-app-env: &app-env
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: "8080"
|
||||
APP_ENV: ${APP_ENV:-lab}
|
||||
LOG_LEVEL: ${LOG_LEVEL:-info}
|
||||
SHUTDOWN_TIMEOUT: ${SHUTDOWN_TIMEOUT:-8}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
SESSION_STORE: ${SESSION_STORE:-redis}
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
CACHE_URL_FILE: /run/secrets/cache_url
|
||||
DB_POOL_MIN_SIZE: ${DB_POOL_MIN_SIZE:-2}
|
||||
DB_POOL_MAX_SIZE: ${DB_POOL_MAX_SIZE:-10}
|
||||
DB_POOL_TIMEOUT: ${DB_POOL_TIMEOUT:-3}
|
||||
DB_CONNECT_TIMEOUT: ${DB_CONNECT_TIMEOUT:-3}
|
||||
DB_STATEMENT_TIMEOUT: ${DB_STATEMENT_TIMEOUT:-5}
|
||||
CACHE_POOL_MAX_SIZE: ${CACHE_POOL_MAX_SIZE:-20}
|
||||
CACHE_TIMEOUT: ${CACHE_TIMEOUT:-2}
|
||||
S3_ENDPOINT: http://s3:9000
|
||||
S3_REGION: ${S3_REGION:-us-east-1}
|
||||
S3_BUCKET: ${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
|
||||
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
|
||||
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
|
||||
MAX_PARALLEL_UPLOADS: ${MAX_PARALLEL_UPLOADS:-32}
|
||||
UPLOAD_TIMEOUT_SECONDS: ${UPLOAD_TIMEOUT_SECONDS:-60}
|
||||
S3_PARALLEL_WRITES: ${S3_PARALLEL_WRITES:-4}
|
||||
S3_WRITE_QUEUE_SECONDS: ${S3_WRITE_QUEUE_SECONDS:-10}
|
||||
|
||||
services:
|
||||
lb:
|
||||
build: infra/haproxy
|
||||
image: mtusi-messenger-lb:lab4
|
||||
# единственный опубликованный порт стенда
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
networks:
|
||||
- edge
|
||||
depends_on:
|
||||
api:
|
||||
condition: service_started
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8404/lb-health"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 128M
|
||||
restart: unless-stopped
|
||||
|
||||
api:
|
||||
<<: *app
|
||||
environment: *app-env
|
||||
secrets:
|
||||
- database_url
|
||||
- cache_url
|
||||
- s3_access_key_id
|
||||
- s3_secret_access_key
|
||||
networks:
|
||||
- edge
|
||||
- data
|
||||
- storage
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
redis:
|
||||
condition: service_healthy
|
||||
s3-init:
|
||||
condition: service_completed_successfully
|
||||
# SIGTERM -> приём закрыт -> незавершённые запросы до SHUTDOWN_TIMEOUT -> выход раньше SIGKILL
|
||||
stop_grace_period: 10s
|
||||
deploy:
|
||||
replicas: ${API_REPLICAS:-2}
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
# 120 МБ сам процесс и до 320 МБ на декодирование прогрессивного JPEG на 40 млн пикселей
|
||||
memory: 512M
|
||||
restart: unless-stopped
|
||||
|
||||
# миграции выполняет один контейнер до старта реплик, а не каждая реплика
|
||||
migrate:
|
||||
<<: *app
|
||||
command: ["python", "migrate.py"]
|
||||
environment:
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
secrets:
|
||||
- database_url
|
||||
networks:
|
||||
- data
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
disable: true
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 128M
|
||||
restart: "no"
|
||||
|
||||
# создаёт bucket; повторный запуск ничего не меняет
|
||||
s3-init:
|
||||
<<: *app
|
||||
command: ["python", "s3_init.py"]
|
||||
environment:
|
||||
S3_ENDPOINT: http://s3:9000
|
||||
S3_REGION: ${S3_REGION:-us-east-1}
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_ADMIN_ACCESS_KEY_ID_FILE: /run/secrets/s3_admin_access_key_id
|
||||
S3_ADMIN_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_admin_secret_access_key
|
||||
secrets:
|
||||
- s3_admin_access_key_id
|
||||
- s3_admin_secret_access_key
|
||||
networks:
|
||||
- storage
|
||||
depends_on:
|
||||
s3:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
disable: true
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 128M
|
||||
restart: "no"
|
||||
|
||||
# убирает следы незавершённых загрузок, ключ S3 у него свой
|
||||
janitor:
|
||||
<<: *app
|
||||
command: ["python", "janitor.py"]
|
||||
environment:
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
S3_ENDPOINT: http://s3:9000
|
||||
S3_REGION: ${S3_REGION:-us-east-1}
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_JANITOR_ACCESS_KEY_ID_FILE: /run/secrets/s3_janitor_access_key_id
|
||||
S3_JANITOR_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_janitor_secret_access_key
|
||||
ATTACHMENT_GRACE_SECONDS: ${ATTACHMENT_GRACE_SECONDS:-3600}
|
||||
JANITOR_INTERVAL_SECONDS: ${JANITOR_INTERVAL_SECONDS:-300}
|
||||
LOG_LEVEL: ${LOG_LEVEL:-info}
|
||||
secrets:
|
||||
- database_url
|
||||
- s3_janitor_access_key_id
|
||||
- s3_janitor_secret_access_key
|
||||
networks:
|
||||
- data
|
||||
- storage
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
s3-init:
|
||||
condition: service_completed_successfully
|
||||
healthcheck:
|
||||
disable: true
|
||||
stop_grace_period: 5s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.25"
|
||||
memory: 128M
|
||||
restart: unless-stopped
|
||||
|
||||
# SeaweedFS: S3 на порту 9000; порты не опубликованы, веб-интерфейс мастера доступен только в сети storage
|
||||
s3:
|
||||
build: infra/s3
|
||||
image: mtusi-messenger-s3:lab4
|
||||
environment:
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
# мягкий предел Go ниже лимита контейнера: сборщик мусора успевает раньше, чем OOM killer
|
||||
GOMEMLIMIT: 768MiB
|
||||
secrets:
|
||||
- s3_admin_access_key_id
|
||||
- s3_admin_secret_access_key
|
||||
- s3_access_key_id
|
||||
- s3_secret_access_key
|
||||
- s3_janitor_access_key_id
|
||||
- s3_janitor_secret_access_key
|
||||
networks:
|
||||
- storage
|
||||
volumes:
|
||||
- s3data:/data
|
||||
healthcheck:
|
||||
# порт S3 открывается раньше, чем мастер узнаёт о томе данных, а до этого запросы к объектам зависают
|
||||
test: ["CMD-SHELL", "wget -q -O- http://127.0.0.1:9333/dir/status | grep -q s3:8080 && wget -q -O /dev/null http://127.0.0.1:9000/healthz"]
|
||||
interval: 3s
|
||||
timeout: 2s
|
||||
retries: 30
|
||||
start_period: 60s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
# при 512 МБ процесс убивался OOM killer при 30 параллельных загрузках по 10 MiB
|
||||
memory: 1024M
|
||||
restart: unless-stopped
|
||||
|
||||
postgres:
|
||||
image: postgres:17.11-alpine
|
||||
environment:
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
|
||||
secrets:
|
||||
- postgres_password
|
||||
networks:
|
||||
- data
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 512M
|
||||
restart: unless-stopped
|
||||
|
||||
redis:
|
||||
image: redis:7.4.11-alpine
|
||||
# сессии хранятся только здесь, поэтому включён AOF с fsync на каждую запись;
|
||||
# запуск через docker-entrypoint.sh, чтобы процесс работал от пользователя redis, а не от root
|
||||
command:
|
||||
- sh
|
||||
- -c
|
||||
- exec docker-entrypoint.sh redis-server --appendonly yes --appendfsync always --requirepass "$$(cat /run/secrets/redis_password)"
|
||||
secrets:
|
||||
- redis_password
|
||||
networks:
|
||||
- data
|
||||
volumes:
|
||||
- redisdata:/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "redis-cli --no-auth-warning -a \"$$(cat /run/secrets/redis_password)\" ping | grep -q PONG"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 128M
|
||||
restart: unless-stopped
|
||||
|
||||
networks:
|
||||
# балансировщик и реплики
|
||||
edge:
|
||||
# реплики и хранилища; балансировщик сюда не входит, выхода наружу нет
|
||||
data:
|
||||
internal: true
|
||||
# реплики и S3; база и Redis отдельно от S3
|
||||
storage:
|
||||
internal: true
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
redisdata:
|
||||
s3data:
|
||||
|
||||
secrets:
|
||||
postgres_password:
|
||||
environment: POSTGRES_PASSWORD
|
||||
redis_password:
|
||||
environment: REDIS_PASSWORD
|
||||
database_url:
|
||||
environment: DATABASE_URL
|
||||
cache_url:
|
||||
environment: CACHE_URL
|
||||
s3_admin_access_key_id:
|
||||
environment: S3_ADMIN_ACCESS_KEY_ID
|
||||
s3_admin_secret_access_key:
|
||||
environment: S3_ADMIN_SECRET_ACCESS_KEY
|
||||
s3_access_key_id:
|
||||
environment: S3_ACCESS_KEY_ID
|
||||
s3_secret_access_key:
|
||||
environment: S3_SECRET_ACCESS_KEY
|
||||
s3_janitor_access_key_id:
|
||||
environment: S3_JANITOR_ACCESS_KEY_ID
|
||||
s3_janitor_secret_access_key:
|
||||
environment: S3_JANITOR_SECRET_ACCESS_KEY
|
||||
@@ -0,0 +1,81 @@
|
||||
# Запуск из чистого clone на пустых volumes, публичный smoke
|
||||
# дата: 2026-10-31T00:55Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
$ make env
|
||||
./scripts/init-env.sh
|
||||
пароли записаны в .env
|
||||
|
||||
$ docker compose --env-file .env config --quiet
|
||||
|
||||
$ docker compose --env-file .env up -d --build
|
||||
Image mtusi-messenger-lb:lab4 Built
|
||||
Image mtusi-messenger-s3:lab4 Built
|
||||
Image mtusi-messenger:lab4 Built
|
||||
Image mtusi-messenger:lab4 Built
|
||||
Image mtusi-messenger:lab4 Built
|
||||
Image mtusi-messenger:lab4 Built
|
||||
Network mtusi-messenger-lab4_data Created
|
||||
Network mtusi-messenger-lab4_storage Created
|
||||
Network mtusi-messenger-lab4_edge Created
|
||||
Volume mtusi-messenger-lab4_redisdata Created
|
||||
Volume mtusi-messenger-lab4_s3data Created
|
||||
Volume mtusi-messenger-lab4_pgdata Created
|
||||
Container mtusi-messenger-lab4-redis-1 Created
|
||||
Container mtusi-messenger-lab4-s3-1 Created
|
||||
Container mtusi-messenger-lab4-postgres-1 Created
|
||||
Container mtusi-messenger-lab4-s3-init-1 Created
|
||||
Container mtusi-messenger-lab4-migrate-1 Created
|
||||
Container mtusi-messenger-lab4-api-1 Created
|
||||
Container mtusi-messenger-lab4-janitor-1 Created
|
||||
Container mtusi-messenger-lab4-api-2 Created
|
||||
Container mtusi-messenger-lab4-lb-1 Created
|
||||
Container mtusi-messenger-lab4-redis-1 Started
|
||||
Container mtusi-messenger-lab4-s3-1 Started
|
||||
Container mtusi-messenger-lab4-postgres-1 Started
|
||||
Container mtusi-messenger-lab4-s3-1 Healthy
|
||||
Container mtusi-messenger-lab4-postgres-1 Healthy
|
||||
Container mtusi-messenger-lab4-s3-init-1 Started
|
||||
Container mtusi-messenger-lab4-migrate-1 Started
|
||||
Container mtusi-messenger-lab4-redis-1 Healthy
|
||||
Container mtusi-messenger-lab4-migrate-1 Exited
|
||||
Container mtusi-messenger-lab4-migrate-1 Exited
|
||||
Container mtusi-messenger-lab4-s3-init-1 Exited
|
||||
Container mtusi-messenger-lab4-s3-init-1 Exited
|
||||
Container mtusi-messenger-lab4-janitor-1 Started
|
||||
Container mtusi-messenger-lab4-api-1 Started
|
||||
Container mtusi-messenger-lab4-api-2 Started
|
||||
Container mtusi-messenger-lab4-lb-1 Started
|
||||
|
||||
$ ./scripts/wait-ready.sh
|
||||
готов: http://localhost:8080
|
||||
|
||||
$ docker compose --env-file .env ps -a
|
||||
SERVICE IMAGE STATE STATUS PORTS
|
||||
api mtusi-messenger:lab4 running Up 4 seconds (healthy) 8080/tcp
|
||||
api mtusi-messenger:lab4 running Up 4 seconds (healthy) 8080/tcp
|
||||
janitor mtusi-messenger:lab4 running Up 4 seconds 8080/tcp
|
||||
lb mtusi-messenger-lb:lab4 running Up 4 seconds (health: starting) 127.0.0.1:8080->8080/tcp
|
||||
migrate mtusi-messenger:lab4 exited Exited (0) 16 seconds ago
|
||||
postgres postgres:17.11-alpine running Up 22 seconds (healthy) 5432/tcp
|
||||
redis redis:7.4.11-alpine running Up 22 seconds (healthy) 6379/tcp
|
||||
s3 mtusi-messenger-s3:lab4 running Up 22 seconds (healthy) 7333/tcp, 8080/tcp, 8333/tcp, 8888/tcp, 9333/tcp, 18080/tcp, 18888/tcp, 19333/tcp
|
||||
s3-init mtusi-messenger:lab4 exited Exited (0) 4 seconds ago
|
||||
|
||||
$ docker compose --env-file .env logs migrate s3-init
|
||||
s3-init-1 | bucket создан: messenger-attachments
|
||||
s3-init-1 | S3 ещё не готов: ReadTimeoutError
|
||||
s3-init-1 | bucket уже есть: messenger-attachments
|
||||
s3-init-1 | пробная запись прошла
|
||||
migrate-1 | применена: 0001_init.sql
|
||||
migrate-1 | применена: 0002_idempotency.sql
|
||||
migrate-1 | применена: 0003_attachments.sql
|
||||
|
||||
$ make check
|
||||
python3 scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
|
||||
$ make test
|
||||
python3 tests/smoke.py --base-url "http://localhost:8080"
|
||||
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
# Сценарий защиты: файл, сообщение, второй участник, посторонний, прямой доступ к S3
|
||||
# дата: 2026-10-31T00:55Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
$ make attachment-demo
|
||||
python3 scripts/attachment_demo.py
|
||||
загрузка: ready 111817 байт, sha256 99ea7533c441f79c
|
||||
сообщение: 201 attachment_ids = 1
|
||||
второй участник скачал: 200 image/png sha256 совпал: True
|
||||
посторонний, метаданные: 404 байты: 404
|
||||
прямой GET в S3 без подписи изнутри сети: 403
|
||||
|
||||
# на реплике нет файла оригинала: временный файл загрузки удалён, поиск по файловой системе проверяет test_no_file_on_api_replica
|
||||
файлов в /tmp: 0
|
||||
@@ -0,0 +1,67 @@
|
||||
# Разбор изображений и сверка с Pillow внутри образа API
|
||||
# дата: 2026-10-31T00:56Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
$ make test-images
|
||||
COPYFILE_DISABLE=1 tar -cf - src/images.py student-tests/samples.py student-tests/image tests/fixtures/sample.png | \
|
||||
docker run --rm -i --entrypoint sh mtusi-messenger:lab4 -c 'cd /tmp && tar -xf - && python -m unittest discover -s student-tests/image -v'
|
||||
tar: Ignoring unknown extended header keyword 'LIBARCHIVE.xattr.com.apple.provenance'
|
||||
tar: Ignoring unknown extended header keyword 'LIBARCHIVE.xattr.com.apple.provenance'
|
||||
tar: Ignoring unknown extended header keyword 'LIBARCHIVE.xattr.com.apple.provenance'
|
||||
tar: Ignoring unknown extended header keyword 'LIBARCHIVE.xattr.com.apple.provenance'
|
||||
tar: Ignoring unknown extended header keyword 'LIBARCHIVE.xattr.com.apple.provenance'
|
||||
tar: Ignoring unknown extended header keyword 'LIBARCHIVE.xattr.com.apple.provenance'
|
||||
test_cut_files (test_against_pillow.AgreementTest.test_cut_files) ... /usr/local/lib/python3.13/site-packages/PIL/TiffImagePlugin.py:982: UserWarning: Corrupt EXIF data. Expecting to read 4 bytes but only got 0.
|
||||
warnings.warn(str(msg))
|
||||
обрезка: принято 370, отвергнуто 2110, принято вопреки Pillow 0
|
||||
ok
|
||||
test_jpeg_with_headers_rebuilt (test_against_pillow.AgreementTest.test_jpeg_with_headers_rebuilt) ... JPEG с настоящими заголовками: принято 792, отвергнуто 8, принято вопреки Pillow 0
|
||||
ok
|
||||
test_png_chunks_shuffled (test_against_pillow.AgreementTest.test_png_chunks_shuffled) ... порядок блоков PNG: принято 0, отвергнуто 600, принято вопреки Pillow 0
|
||||
ok
|
||||
test_png_with_recomputed_crc (test_against_pillow.AgreementTest.test_png_with_recomputed_crc)
|
||||
Самый важный случай: заголовок и CRC верны, испорчено только содержимое. Именно такой файл и был в замечании. ... ok
|
||||
test_random_bytes_changed (test_against_pillow.AgreementTest.test_random_bytes_changed) ... PNG с верными CRC: принято 1354, отвергнуто 146, принято вопреки Pillow 0
|
||||
ok
|
||||
test_every_valid_file_is_accepted (test_against_pillow.ValidFilesTest.test_every_valid_file_is_accepted) ... замена байтов: принято 2218, отвергнуто 3982, принято вопреки Pillow 0
|
||||
ok
|
||||
test_jpeg_without_frame_or_scan (test_images.BrokenImagesTest.test_jpeg_without_frame_or_scan) ... ok
|
||||
test_not_images (test_images.BrokenImagesTest.test_not_images) ... ok
|
||||
test_png_bad_crc (test_images.BrokenImagesTest.test_png_bad_crc) ... ok
|
||||
test_png_data_after_compressed_stream_in_zero_size (test_images.BrokenImagesTest.test_png_data_after_compressed_stream_in_zero_size) ... ok
|
||||
test_png_data_after_end (test_images.BrokenImagesTest.test_png_data_after_end) ... ok
|
||||
test_png_data_is_not_zlib (test_images.BrokenImagesTest.test_png_data_is_not_zlib) ... ok
|
||||
test_png_with_wrong_amount_of_pixels (test_images.BrokenImagesTest.test_png_with_wrong_amount_of_pixels) ... ok
|
||||
test_png_zero_size (test_images.BrokenImagesTest.test_png_zero_size) ... ok
|
||||
test_random_corruption_never_crashes (test_images.BrokenImagesTest.test_random_corruption_never_crashes) ... ok
|
||||
test_truncated (test_images.BrokenImagesTest.test_truncated) ... ok
|
||||
test_big_frame_with_tiny_scan (test_images.JpegContentTest.test_big_frame_with_tiny_scan) ... ok
|
||||
test_broken_frame_header (test_images.JpegContentTest.test_broken_frame_header) ... ok
|
||||
test_scan_replaced_by_almost_nothing (test_images.JpegContentTest.test_scan_replaced_by_almost_nothing) ... ok
|
||||
test_too_many_scans (test_images.JpegContentTest.test_too_many_scans) ... ok
|
||||
test_truncated_with_end_marker_added (test_images.JpegContentTest.test_truncated_with_end_marker_added) ... ok
|
||||
test_without_huffman_tables_like_mjpeg (test_images.JpegContentTest.test_without_huffman_tables_like_mjpeg) ... ok
|
||||
test_without_quantization_tables (test_images.JpegContentTest.test_without_quantization_tables) ... ok
|
||||
test_jpeg_over_limit (test_images.PixelLimitTest.test_jpeg_over_limit) ... ok
|
||||
test_limit_is_exact (test_images.PixelLimitTest.test_limit_is_exact) ... ok
|
||||
test_png_bomb_is_rejected_before_unpacking (test_images.PixelLimitTest.test_png_bomb_is_rejected_before_unpacking) ... ok
|
||||
test_all_valid_filters (test_images.PngContentTest.test_all_valid_filters) ... ok
|
||||
test_bad_filter_in_any_row (test_images.PngContentTest.test_bad_filter_in_any_row) ... ok
|
||||
test_chunk_order (test_images.PngContentTest.test_chunk_order) ... ok
|
||||
test_filter_check_crosses_inflate_blocks (test_images.PngContentTest.test_filter_check_crosses_inflate_blocks) ... ok
|
||||
test_garbage_after_compressed_data (test_images.PngContentTest.test_garbage_after_compressed_data) ... ok
|
||||
test_interlaced (test_images.PngContentTest.test_interlaced) ... ok
|
||||
test_many_short_rows_are_checked_quickly (test_images.PngContentTest.test_many_short_rows_are_checked_quickly) ... ok
|
||||
test_palette_rules (test_images.PngContentTest.test_palette_rules) ... ok
|
||||
test_course_fixture (test_images.RealImagesTest.test_course_fixture) ... ok
|
||||
test_jpeg_with_data_after_end (test_images.RealImagesTest.test_jpeg_with_data_after_end) ... ok
|
||||
test_marker_on_block_border (test_images.RealImagesTest.test_marker_on_block_border) ... ok
|
||||
test_real_images_are_accepted (test_images.RealImagesTest.test_real_images_are_accepted) ... ok
|
||||
test_jpeg_without_image_data (test_images.ReviewCasesTest.test_jpeg_without_image_data) ... ok
|
||||
test_png_with_invalid_filter_byte (test_images.ReviewCasesTest.test_png_with_invalid_filter_byte) ... ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 40 tests in 0.952s
|
||||
|
||||
OK
|
||||
|
||||
@@ -0,0 +1,143 @@
|
||||
# Собственные тесты API и вложений
|
||||
# дата: 2026-10-31T00:55Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
$ make student-test
|
||||
BASE_URL="http://localhost:8080" python3 -m unittest discover -s student-tests -v
|
||||
test_blank_title (test_access.CreateChatTest.test_blank_title) ... ok
|
||||
test_creator_must_be_member (test_access.CreateChatTest.test_creator_must_be_member) ... ok
|
||||
test_duplicate_members (test_access.CreateChatTest.test_duplicate_members) ... ok
|
||||
test_empty_members (test_access.CreateChatTest.test_empty_members) ... ok
|
||||
test_failed_create_leaves_no_chat (test_access.CreateChatTest.test_failed_create_leaves_no_chat) ... ok
|
||||
test_unknown_member (test_access.CreateChatTest.test_unknown_member) ... ok
|
||||
test_bad_chat_id (test_access.ForeignChatTest.test_bad_chat_id) ... ok
|
||||
test_chat_is_not_listed_for_outsider (test_access.ForeignChatTest.test_chat_is_not_listed_for_outsider) ... ok
|
||||
test_foreign_chat_looks_like_missing_chat (test_access.ForeignChatTest.test_foreign_chat_looks_like_missing_chat) ... ok
|
||||
test_member_id_must_be_canonical_uuid (test_access.ForeignChatTest.test_member_id_must_be_canonical_uuid) ... ok
|
||||
test_members_can_read_and_write (test_access.ForeignChatTest.test_members_can_read_and_write) ... ok
|
||||
test_outsider_gets_404_everywhere (test_access.ForeignChatTest.test_outsider_gets_404_everywhere) ... ok
|
||||
test_outsider_message_is_not_saved (test_access.ForeignChatTest.test_outsider_message_is_not_saved) ... ok
|
||||
test_bad_ids (test_attachments.AccessTest.test_bad_ids) ... ok
|
||||
test_download_never_redirects (test_attachments.AccessTest.test_download_never_redirects) ... ok
|
||||
test_no_token (test_attachments.AccessTest.test_no_token) ... ok
|
||||
test_outsider_cannot_upload (test_attachments.AccessTest.test_outsider_cannot_upload) ... ok
|
||||
test_outsider_gets_404 (test_attachments.AccessTest.test_outsider_gets_404) ... ok
|
||||
test_outsider_looks_the_same_as_missing (test_attachments.AccessTest.test_outsider_looks_the_same_as_missing) ... ok
|
||||
test_variants (test_attachments.AccessTest.test_variants) ... ok
|
||||
test_broken_images (test_attachments.ContentCheckTest.test_broken_images) ... ok
|
||||
test_extension_is_not_trusted (test_attachments.ContentCheckTest.test_extension_is_not_trusted) ... ok
|
||||
test_files_from_review (test_attachments.ContentCheckTest.test_files_from_review) ... ok
|
||||
test_mime_spoofing (test_attachments.ContentCheckTest.test_mime_spoofing) ... ok
|
||||
test_unsupported_content_type (test_attachments.ContentCheckTest.test_unsupported_content_type) ... ok
|
||||
test_bad_filenames (test_attachments.FilenameTest.test_bad_filenames) ... ok
|
||||
test_good_filenames (test_attachments.FilenameTest.test_good_filenames) ... ok
|
||||
test_missing_filename (test_attachments.FilenameTest.test_missing_filename) ... ok
|
||||
test_decompression_bomb (test_attachments.LimitsTest.test_decompression_bomb) ... ok
|
||||
test_empty_file (test_attachments.LimitsTest.test_empty_file) ... ok
|
||||
test_pixels_over_limit_with_small_file (test_attachments.LimitsTest.test_pixels_over_limit_with_small_file) ... ok
|
||||
test_too_large_chunked (test_attachments.LimitsTest.test_too_large_chunked) ... ok
|
||||
test_too_large_for_balancer (test_attachments.LimitsTest.test_too_large_for_balancer) ... ok
|
||||
test_too_large_with_length (test_attachments.LimitsTest.test_too_large_with_length) ... ok
|
||||
test_attachment_of_my_other_chat (test_attachments.MessageLinkTest.test_attachment_of_my_other_chat) ... ok
|
||||
test_attachment_only_message (test_attachments.MessageLinkTest.test_attachment_only_message) ... ok
|
||||
test_empty_message_without_attachments (test_attachments.MessageLinkTest.test_empty_message_without_attachments) ... ok
|
||||
test_failed_link_saves_nothing_and_frees_key (test_attachments.MessageLinkTest.test_failed_link_saves_nothing_and_frees_key) ... ok
|
||||
test_foreign_attachment (test_attachments.MessageLinkTest.test_foreign_attachment) ... ok
|
||||
test_idempotent_repeat (test_attachments.MessageLinkTest.test_idempotent_repeat) ... ok
|
||||
test_limits (test_attachments.MessageLinkTest.test_limits) ... ok
|
||||
test_message_with_attachments (test_attachments.MessageLinkTest.test_message_with_attachments) ... ok
|
||||
test_missing_list_equals_empty_list (test_attachments.MessageLinkTest.test_missing_list_equals_empty_list) ... ok
|
||||
test_one_file_in_two_messages (test_attachments.MessageLinkTest.test_one_file_in_two_messages) ... ok
|
||||
test_ten_attachments (test_attachments.MessageLinkTest.test_ten_attachments) ... ok
|
||||
test_text_message_has_empty_list (test_attachments.MessageLinkTest.test_text_message_has_empty_list) ... ok
|
||||
test_unknown_attachment (test_attachments.MessageLinkTest.test_unknown_attachment) ... ok
|
||||
test_too_many_parallel_uploads_get_429 (test_attachments.ParallelLimitTest.test_too_many_parallel_uploads_get_429) ... ok
|
||||
test_attachment_fields (test_attachments.UploadTest.test_attachment_fields) ... ok
|
||||
test_download_headers (test_attachments.UploadTest.test_download_headers) ... ok
|
||||
test_file_of_exactly_10_mib (test_attachments.UploadTest.test_file_of_exactly_10_mib) ... ok
|
||||
test_one_byte_over_10_mib (test_attachments.UploadTest.test_one_byte_over_10_mib) ... ok
|
||||
test_upload_and_download_real_images (test_attachments.UploadTest.test_upload_and_download_real_images) ... ok
|
||||
test_basic_is_not_accepted_on_business_endpoints (test_auth.BearerTest.test_basic_is_not_accepted_on_business_endpoints) ... ok
|
||||
test_garbage_token_is_401_not_500 (test_auth.BearerTest.test_garbage_token_is_401_not_500) ... ok
|
||||
test_no_token (test_auth.BearerTest.test_no_token) ... ok
|
||||
test_token_is_checked_before_anything_else (test_auth.BearerTest.test_token_is_checked_before_anything_else) ... ok
|
||||
test_unknown_tokens (test_auth.BearerTest.test_unknown_tokens) ... ok
|
||||
test_x_user_id_does_not_change_identity (test_auth.BearerTest.test_x_user_id_does_not_change_identity) ... ok
|
||||
test_x_user_id_gives_no_access (test_auth.BearerTest.test_x_user_id_gives_no_access) ... ok
|
||||
test_colon_and_unicode_in_password (test_auth.LoginTest.test_colon_and_unicode_in_password) ... ok
|
||||
test_garbage_after_basic_is_401_not_500 (test_auth.LoginTest.test_garbage_after_basic_is_401_not_500) ... ok
|
||||
test_login (test_auth.LoginTest.test_login) ... ok
|
||||
test_malformed_credentials (test_auth.LoginTest.test_malformed_credentials) ... ok
|
||||
test_token_is_opaque_and_unique (test_auth.LoginTest.test_token_is_opaque_and_unique) ... ok
|
||||
test_username_that_cannot_exist (test_auth.LoginTest.test_username_that_cannot_exist) ... ok
|
||||
test_wrong_password_and_unknown_user_look_the_same (test_auth.LoginTest.test_wrong_password_and_unknown_user_look_the_same) ... ok
|
||||
test_login_again_after_logout (test_auth.LogoutTest.test_login_again_after_logout) ... ok
|
||||
test_logout_requires_token (test_auth.LogoutTest.test_logout_requires_token) ... ok
|
||||
test_logout_revokes_only_current_session (test_auth.LogoutTest.test_logout_revokes_only_current_session) ... ok
|
||||
test_invalid_http (test_balancing.ErrorsFromBalancerTest.test_invalid_http) ... ok
|
||||
test_too_large_headers (test_balancing.ErrorsFromBalancerTest.test_too_large_headers) ... ok
|
||||
test_too_long_uri (test_balancing.ErrorsFromBalancerTest.test_too_long_uri) ... ok
|
||||
test_every_answer_has_instance_id (test_balancing.ReplicasTest.test_every_answer_has_instance_id) ... ok
|
||||
test_logout_works_on_all_replicas (test_balancing.ReplicasTest.test_logout_works_on_all_replicas) ... ok
|
||||
test_no_sticky_cookie (test_balancing.ReplicasTest.test_no_sticky_cookie) ... ok
|
||||
test_one_session_is_served_by_different_replicas (test_balancing.ReplicasTest.test_one_session_is_served_by_different_replicas) ... ok
|
||||
test_read_after_write_on_any_replica (test_balancing.ReplicasTest.test_read_after_write_on_any_replica) ... ok
|
||||
test_session_created_on_one_replica_works_on_all (test_balancing.ReplicasTest.test_session_created_on_one_replica_works_on_all) ... ok
|
||||
test_100_messages_from_10_clients (test_concurrency.ConcurrencyTest.test_100_messages_from_10_clients) ... ok
|
||||
test_same_username_registered_once (test_concurrency.ConcurrencyTest.test_same_username_registered_once) ... ok
|
||||
test_bad_keys (test_idempotency.IdempotencyTest.test_bad_keys) ... ok
|
||||
test_good_key_alphabet (test_idempotency.IdempotencyTest.test_good_key_alphabet) ... ok
|
||||
test_invalid_body_does_not_take_key (test_idempotency.IdempotencyTest.test_invalid_body_does_not_take_key) ... ok
|
||||
test_key_is_required (test_idempotency.IdempotencyTest.test_key_is_required) ... ok
|
||||
test_key_order_in_json_does_not_matter (test_idempotency.IdempotencyTest.test_key_order_in_json_does_not_matter) ... ok
|
||||
test_other_text_with_same_key_is_409 (test_idempotency.IdempotencyTest.test_other_text_with_same_key_is_409) ... ok
|
||||
test_parallel_repeat_through_different_replicas (test_idempotency.IdempotencyTest.test_parallel_repeat_through_different_replicas) ... ok
|
||||
test_repeat_checks_access_again (test_idempotency.IdempotencyTest.test_repeat_checks_access_again) ... ok
|
||||
test_repeat_returns_same_message (test_idempotency.IdempotencyTest.test_repeat_returns_same_message) ... ok
|
||||
test_same_key_for_other_user_and_other_chat (test_idempotency.IdempotencyTest.test_same_key_for_other_user_and_other_chat) ... ok
|
||||
test_chat_cursor_belongs_to_user (test_pagination.ChatPaginationTest.test_chat_cursor_belongs_to_user) ... ok
|
||||
test_walk_chat_list (test_pagination.ChatPaginationTest.test_walk_chat_list) ... ok
|
||||
test_bad_cursor (test_pagination.MessagePaginationTest.test_bad_cursor) ... ok
|
||||
test_bad_limit (test_pagination.MessagePaginationTest.test_bad_limit) ... ok
|
||||
test_cursor_format_is_checked (test_pagination.MessagePaginationTest.test_cursor_format_is_checked) ... ok
|
||||
test_cursor_from_another_chat (test_pagination.MessagePaginationTest.test_cursor_from_another_chat) ... ok
|
||||
test_default_limit (test_pagination.MessagePaginationTest.test_default_limit) ... ok
|
||||
test_exact_page_has_no_cursor (test_pagination.MessagePaginationTest.test_exact_page_has_no_cursor) ... ok
|
||||
test_limit_can_change_between_pages (test_pagination.MessagePaginationTest.test_limit_can_change_between_pages) ... ok
|
||||
test_new_message_appears_after_last_page (test_pagination.MessagePaginationTest.test_new_message_appears_after_last_page) ... ok
|
||||
test_no_duplicates_and_order (test_pagination.MessagePaginationTest.test_no_duplicates_and_order) ... ok
|
||||
test_walk_several_pages (test_pagination.MessagePaginationTest.test_walk_several_pages) ... ok
|
||||
test_broken_json_without_token_is_401 (test_validation.InvalidJsonTest.test_broken_json_without_token_is_401) ... ok
|
||||
test_content_type_must_be_json (test_validation.InvalidJsonTest.test_content_type_must_be_json) ... ok
|
||||
test_deeply_nested_json (test_validation.InvalidJsonTest.test_deeply_nested_json) ... ok
|
||||
test_extra_field (test_validation.InvalidJsonTest.test_extra_field) ... ok
|
||||
test_malformed_json (test_validation.InvalidJsonTest.test_malformed_json) ... ok
|
||||
test_malformed_json_in_message (test_validation.InvalidJsonTest.test_malformed_json_in_message) ... ok
|
||||
test_missing_field (test_validation.InvalidJsonTest.test_missing_field) ... ok
|
||||
test_not_an_object (test_validation.InvalidJsonTest.test_not_an_object) ... ok
|
||||
test_only_utf8_is_accepted (test_validation.InvalidJsonTest.test_only_utf8_is_accepted) ... ok
|
||||
test_too_large_json (test_validation.InvalidJsonTest.test_too_large_json) ... ok
|
||||
test_wrong_type (test_validation.InvalidJsonTest.test_wrong_type) ... ok
|
||||
test_empty_message (test_validation.MessageValidationTest.test_empty_message) ... ok
|
||||
test_nul_character (test_validation.MessageValidationTest.test_nul_character) ... ok
|
||||
test_sender_id_is_not_accepted (test_validation.MessageValidationTest.test_sender_id_is_not_accepted) ... ok
|
||||
test_text_limit (test_validation.MessageValidationTest.test_text_limit) ... ok
|
||||
test_unicode_is_kept (test_validation.MessageValidationTest.test_unicode_is_kept) ... ok
|
||||
test_whitespace_message (test_validation.MessageValidationTest.test_whitespace_message) ... ok
|
||||
test_bad_display_names (test_validation.UserValidationTest.test_bad_display_names) ... ok
|
||||
test_bad_passwords (test_validation.UserValidationTest.test_bad_passwords) ... ok
|
||||
test_bad_usernames (test_validation.UserValidationTest.test_bad_usernames) ... ok
|
||||
test_display_name_length_is_counted_in_code_points (test_validation.UserValidationTest.test_display_name_length_is_counted_in_code_points) ... ok
|
||||
test_duplicate_username (test_validation.UserValidationTest.test_duplicate_username) ... ok
|
||||
test_password_is_never_returned (test_validation.UserValidationTest.test_password_is_never_returned) ... ok
|
||||
test_password_length_limits (test_validation.UserValidationTest.test_password_length_limits) ... ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 127 tests in 7.860s
|
||||
|
||||
OK
|
||||
|
||||
отправлено 100, подтверждено 100, в истории 100, уникальных id 100
|
||||
|
||||
10 ключей по 8 параллельных запросов: реплик 2, сообщений в истории 10
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
# Сохранность: перезапуск всего стенда с сохранением volumes, включая оригинал файла
|
||||
# дата: 2026-10-31T00:56Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
# до перезапуска
|
||||
/mtusi-messenger-lab4-api-1 StartedAt=2026-10-31T00:55:51.019629833Z
|
||||
/mtusi-messenger-lab4-api-2 StartedAt=2026-10-31T00:55:51.155422333Z
|
||||
/mtusi-messenger-lab4-janitor-1 StartedAt=2026-10-31T00:55:51.019948375Z
|
||||
/mtusi-messenger-lab4-lb-1 StartedAt=2026-10-31T00:55:51.246447042Z
|
||||
/mtusi-messenger-lab4-postgres-1 StartedAt=2026-10-31T00:55:33.238815464Z
|
||||
/mtusi-messenger-lab4-redis-1 StartedAt=2026-10-31T00:55:33.238242006Z
|
||||
/mtusi-messenger-lab4-s3-1 StartedAt=2026-10-31T00:55:33.268518673Z
|
||||
|
||||
$ cat scripts/restart.sh
|
||||
#!/bin/sh
|
||||
# Перезапускает балансировщик, все реплики API, janitor и все хранилища. Volumes не трогает.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env restart postgres redis s3 api janitor lb
|
||||
|
||||
# /health/ready от S3 не зависит, поэтому готовность S3 ждём здесь: том данных появляется за 20-30 секунд
|
||||
container=$(docker compose --env-file .env ps -q s3)
|
||||
for attempt in $(seq 1 80); do
|
||||
[ "$(docker inspect -f '{{.State.Health.Status}}' "$container")" = healthy ] && exit 0
|
||||
sleep 1
|
||||
done
|
||||
echo "S3 не стал готов за 80 секунд" >&2
|
||||
exit 1
|
||||
|
||||
$ make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --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.
|
||||
|
||||
# после перезапуска: новое время старта у всех контейнеров
|
||||
/mtusi-messenger-lab4-api-1 StartedAt=2026-10-31T00:56:08.283900967Z
|
||||
/mtusi-messenger-lab4-api-2 StartedAt=2026-10-31T00:56:08.204635217Z
|
||||
/mtusi-messenger-lab4-janitor-1 StartedAt=2026-10-31T00:56:08.100580008Z
|
||||
/mtusi-messenger-lab4-lb-1 StartedAt=2026-10-31T00:56:07.638958341Z
|
||||
/mtusi-messenger-lab4-postgres-1 StartedAt=2026-10-31T00:56:07.709906466Z
|
||||
/mtusi-messenger-lab4-redis-1 StartedAt=2026-10-31T00:56:07.679625675Z
|
||||
/mtusi-messenger-lab4-s3-1 StartedAt=2026-10-31T00:56:08.466819675Z
|
||||
|
||||
$ docker volume ls --filter name=mtusi-messenger-lab4
|
||||
DRIVER VOLUME NAME
|
||||
local mtusi-messenger-lab4_pgdata
|
||||
local mtusi-messenger-lab4_redisdata
|
||||
local mtusi-messenger-lab4_s3data
|
||||
|
||||
# повторный запуск миграций и создания bucket
|
||||
$ docker compose --env-file .env run --rm --no-deps migrate
|
||||
Container mtusi-messenger-lab4-migrate-run-cf6cc716b21e Creating
|
||||
Container mtusi-messenger-lab4-migrate-run-cf6cc716b21e Created
|
||||
уже применена: 0001_init.sql
|
||||
уже применена: 0002_idempotency.sql
|
||||
уже применена: 0003_attachments.sql
|
||||
|
||||
$ docker compose --env-file .env run --rm --no-deps s3-init
|
||||
Container mtusi-messenger-lab4-s3-init-run-1a7c3702d2be Creating
|
||||
Container mtusi-messenger-lab4-s3-init-run-1a7c3702d2be Created
|
||||
bucket уже есть: messenger-attachments
|
||||
пробная запись прошла
|
||||
|
||||
@@ -0,0 +1,88 @@
|
||||
# Публичный failover: файл загружен, обслужившая реплика остановлена, скачивание через другую; два прогона
|
||||
# дата: 2026-10-31T00:56Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
## прогон 1
|
||||
# реплики до отказа
|
||||
NAME STATE STATUS
|
||||
mtusi-messenger-lab4-api-1 running Up 38 seconds (healthy)
|
||||
mtusi-messenger-lab4-api-2 running Up 38 seconds (healthy)
|
||||
|
||||
$ make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080"
|
||||
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
|
||||
{"observed_instances_before": 2, "successful_writes": 120, "failed_attempts": 0, "first_recovery_seconds": 2.065}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
|
||||
# какой контейнер реально остановлен
|
||||
NAME STATE STATUS
|
||||
mtusi-messenger-lab4-api-1 running Up 53 seconds (healthy)
|
||||
mtusi-messenger-lab4-api-2 exited Exited (0) 14 seconds ago
|
||||
|
||||
$ make restore
|
||||
docker compose --env-file .env up -d --no-recreate --no-build api
|
||||
Container mtusi-messenger-lab4-redis-1 Running
|
||||
Container mtusi-messenger-lab4-s3-1 Running
|
||||
Container mtusi-messenger-lab4-postgres-1 Running
|
||||
Container mtusi-messenger-lab4-api-1 Running
|
||||
Container mtusi-messenger-lab4-postgres-1 Waiting
|
||||
Container mtusi-messenger-lab4-s3-1 Waiting
|
||||
Container mtusi-messenger-lab4-s3-1 Healthy
|
||||
Container mtusi-messenger-lab4-postgres-1 Healthy
|
||||
Container mtusi-messenger-lab4-migrate-1 Starting
|
||||
Container mtusi-messenger-lab4-s3-init-1 Starting
|
||||
Container mtusi-messenger-lab4-s3-init-1 Started
|
||||
Container mtusi-messenger-lab4-migrate-1 Started
|
||||
Container mtusi-messenger-lab4-redis-1 Waiting
|
||||
Container mtusi-messenger-lab4-s3-init-1 Waiting
|
||||
Container mtusi-messenger-lab4-migrate-1 Waiting
|
||||
Container mtusi-messenger-lab4-redis-1 Healthy
|
||||
Container mtusi-messenger-lab4-migrate-1 Exited
|
||||
Container mtusi-messenger-lab4-s3-init-1 Exited
|
||||
Container mtusi-messenger-lab4-api-2 Starting
|
||||
Container mtusi-messenger-lab4-api-2 Started
|
||||
BASE_URL="http://localhost:8080" ./scripts/wait-ready.sh
|
||||
готов: http://localhost:8080
|
||||
|
||||
## прогон 2
|
||||
# реплики до отказа
|
||||
NAME STATE STATUS
|
||||
mtusi-messenger-lab4-api-1 running Up 59 seconds (healthy)
|
||||
mtusi-messenger-lab4-api-2 running Up 4 seconds (healthy)
|
||||
|
||||
$ make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080"
|
||||
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
|
||||
{"observed_instances_before": 2, "successful_writes": 121, "failed_attempts": 0, "first_recovery_seconds": 1.691}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
|
||||
# какой контейнер реально остановлен
|
||||
NAME STATE STATUS
|
||||
mtusi-messenger-lab4-api-1 running Up About a minute (healthy)
|
||||
mtusi-messenger-lab4-api-2 exited Exited (0) 14 seconds ago
|
||||
|
||||
$ make restore
|
||||
docker compose --env-file .env up -d --no-recreate --no-build api
|
||||
Container mtusi-messenger-lab4-s3-1 Running
|
||||
Container mtusi-messenger-lab4-redis-1 Running
|
||||
Container mtusi-messenger-lab4-postgres-1 Running
|
||||
Container mtusi-messenger-lab4-api-1 Running
|
||||
Container mtusi-messenger-lab4-s3-1 Waiting
|
||||
Container mtusi-messenger-lab4-postgres-1 Waiting
|
||||
Container mtusi-messenger-lab4-postgres-1 Healthy
|
||||
Container mtusi-messenger-lab4-s3-1 Healthy
|
||||
Container mtusi-messenger-lab4-migrate-1 Starting
|
||||
Container mtusi-messenger-lab4-s3-init-1 Starting
|
||||
Container mtusi-messenger-lab4-migrate-1 Started
|
||||
Container mtusi-messenger-lab4-s3-init-1 Started
|
||||
Container mtusi-messenger-lab4-migrate-1 Waiting
|
||||
Container mtusi-messenger-lab4-redis-1 Waiting
|
||||
Container mtusi-messenger-lab4-s3-init-1 Waiting
|
||||
Container mtusi-messenger-lab4-redis-1 Healthy
|
||||
Container mtusi-messenger-lab4-s3-init-1 Exited
|
||||
Container mtusi-messenger-lab4-migrate-1 Exited
|
||||
Container mtusi-messenger-lab4-api-2 Starting
|
||||
Container mtusi-messenger-lab4-api-2 Started
|
||||
BASE_URL="http://localhost:8080" ./scripts/wait-ready.sh
|
||||
готов: http://localhost:8080
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
# Остановка каждой реплики под нагрузкой (SIGTERM), полные данные в failover-each.json
|
||||
# дата: 2026-10-31T00:57Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
$ make failover-each
|
||||
BASE_URL="http://localhost:8080" python3 scripts/chaos.py stop --output evidence/failover-each.json
|
||||
{"seconds": 18.19, "successful_requests": 8333, "failed_attempts": 0, "failed_statuses": [], "successful_rps": 458.1, "longest_gap_between_successes_s": 0.997, "first_success_after_action_s": 0.004, "last_success_on_target_after_action_s": 13.188, "instances_seen": 2, "target": "e0ce1c223b49", "signal": "SIGTERM", "stop_command_s": 0.59, "excluded_by_lb_after_s": 1.63, "verify": {"confirmed": 8333, "in_history": 8333, "lost_confirmed": 0, "duplicate_ids": 0, "duplicate_texts": 0, "unconfirmed_but_saved": 0}}
|
||||
{"seconds": 19.85, "successful_requests": 9258, "failed_attempts": 1, "failed_statuses": [502], "successful_rps": 466.3, "longest_gap_between_successes_s": 1.016, "first_success_after_action_s": 0.005, "last_success_on_target_after_action_s": 14.853, "instances_seen": 2, "target": "6e7001b3af3a", "signal": "SIGTERM", "stop_command_s": 0.66, "excluded_by_lb_after_s": 0.78, "verify": {"confirmed": 9258, "in_history": 9258, "lost_confirmed": 0, "duplicate_ids": 0, "duplicate_texts": 0, "unconfirmed_but_saved": 0}}
|
||||
PASS: подтверждённые сообщения на месте, дублей нет
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
# Поочерёдная замена реплик под нагрузкой, полные данные в rolling-update.json
|
||||
# дата: 2026-10-31T00:58Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
# образы до замены
|
||||
/mtusi-messenger-lab4-api-1 sha256:53d2e279c4c191e566b6dd52082c532a7a4
|
||||
/mtusi-messenger-lab4-api-2 sha256:53d2e279c4c191e566b6dd52082c532a7a4
|
||||
|
||||
$ make rolling-update APP_VERSION=2
|
||||
BASE_URL="http://localhost:8080" python3 scripts/chaos.py rolling --output evidence/rolling-update.json
|
||||
{"seconds": 24.77, "successful_requests": 13125, "failed_attempts": 0, "failed_statuses": [], "successful_rps": 529.8, "longest_gap_between_successes_s": 0.995, "first_success_after_action_s": 0.0, "last_success_on_target_after_action_s": null, "instances_seen": 4, "update_seconds": 14.77, "containers_before": {"e0ce1c223b49": "sha256:53d2e279c4c1", "6e7001b3af3a": "sha256:53d2e279c4c1"}, "containers_after": {"504924bd9076": "sha256:e71bfdb1c725", "ec77c0e85d5c": "sha256:e71bfdb1c725"}, "app_version": "2", "verify": {"confirmed": 13125, "in_history": 13125, "lost_confirmed": 0, "duplicate_ids": 0, "duplicate_texts": 0, "unconfirmed_but_saved": 0}}
|
||||
PASS: подтверждённые сообщения на месте, дублей нет
|
||||
|
||||
# образы и версия после замены
|
||||
/mtusi-messenger-lab4-api-3 sha256:e71bfdb1c7251e1ff3cba0fe406a31058f3 APP_VERSION=2
|
||||
/mtusi-messenger-lab4-api-4 sha256:e71bfdb1c7251e1ff3cba0fe406a31058f3 APP_VERSION=2
|
||||
@@ -0,0 +1,43 @@
|
||||
# Тесты отказов: сбой между S3 и БД, отказ S3, приватность bucket, истечение, отказ Redis и PostgreSQL, транзакции
|
||||
# дата: 2026-10-31T00:58Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
$ make test-failures
|
||||
BASE_URL="http://localhost:8080" python3 -m unittest discover -s student-tests/failures -v
|
||||
test_postgres_down (test_dependencies.DependencyDownTest.test_postgres_down) ... ok
|
||||
test_redis_down (test_dependencies.DependencyDownTest.test_redis_down) ... ok
|
||||
test_uncertain_write_can_be_repeated_with_same_key (test_dependencies.DependencyDownTest.test_uncertain_write_can_be_repeated_with_same_key) ... ok
|
||||
test_expires_at_matches_ttl (test_expiry.SessionExpiryTest.test_expires_at_matches_ttl) ... ok
|
||||
test_idempotency_key_is_free_after_ttl (test_expiry.SessionExpiryTest.test_idempotency_key_is_free_after_ttl) ... ok
|
||||
test_login_after_expiry (test_expiry.SessionExpiryTest.test_login_after_expiry) ... ok
|
||||
test_requests_do_not_extend_session (test_expiry.SessionExpiryTest.test_requests_do_not_extend_session) ... ok
|
||||
test_session_expires (test_expiry.SessionExpiryTest.test_session_expires) ... ok
|
||||
test_commit_lost_after_s3_put (test_storage.ConsistencyTest.test_commit_lost_after_s3_put)
|
||||
Состояние как после падения между PUT и подтверждением: объект есть, строка pending, клиент не получил 201. ... ok
|
||||
test_grace_period_protects_fresh_upload (test_storage.ConsistencyTest.test_grace_period_protects_fresh_upload) ... ok
|
||||
test_interrupted_upload_leaves_nothing (test_storage.ConsistencyTest.test_interrupted_upload_leaves_nothing) ... ok
|
||||
test_orphan_object_is_removed_only_after_grace (test_storage.ConsistencyTest.test_orphan_object_is_removed_only_after_grace) ... ok
|
||||
test_postgres_lost_during_parallel_uploads (test_storage.ConsistencyTest.test_postgres_lost_during_parallel_uploads)
|
||||
Настоящий сбой: база пропадает, пока идут загрузки. Часть объектов попадает в S3 без подтверждения. ... ok
|
||||
test_ready_attachments_are_never_removed (test_storage.ConsistencyTest.test_ready_attachments_are_never_removed) ... ok
|
||||
test_second_pass_changes_nothing (test_storage.ConsistencyTest.test_second_pass_changes_nothing) ... ok
|
||||
test_bucket_bootstrap_can_be_repeated (test_storage.PrivateBucketTest.test_bucket_bootstrap_can_be_repeated) ... ok
|
||||
test_bucket_is_private_and_api_key_is_limited (test_storage.PrivateBucketTest.test_bucket_is_private_and_api_key_is_limited) ... ok
|
||||
test_no_file_on_api_replica (test_storage.PrivateBucketTest.test_no_file_on_api_replica) ... ok
|
||||
test_failed_upload_is_cleaned (test_storage.S3DownTest.test_failed_upload_is_cleaned) ... ok
|
||||
test_s3_down (test_storage.S3DownTest.test_s3_down) ... ok
|
||||
test_chat_with_unknown_member_is_rolled_back (test_transactions.TransactionTest.test_chat_with_unknown_member_is_rolled_back) ... ok
|
||||
test_failed_message_leaves_no_key (test_transactions.TransactionTest.test_failed_message_leaves_no_key) ... ok
|
||||
test_migrations_can_be_repeated (test_transactions.TransactionTest.test_migrations_can_be_repeated) ... ok
|
||||
test_password_is_stored_as_argon2id_hash (test_transactions.TransactionTest.test_password_is_stored_as_argon2id_hash) ... ok
|
||||
test_same_key_in_parallel_creates_one_row (test_transactions.TransactionTest.test_same_key_in_parallel_creates_one_row) ... ok
|
||||
test_username_race_creates_one_row (test_transactions.TransactionTest.test_username_race_creates_one_row) ... ok
|
||||
test_valid_chat_is_committed_whole (test_transactions.TransactionTest.test_valid_chat_is_committed_whole) ... ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 27 tests in 310.107s
|
||||
|
||||
OK
|
||||
|
||||
подтверждено 3, в S3 без подтверждения 8, после очистки расхождений нет
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
# Память при одновременных загрузках, полные данные последнего прогона в upload-peak.json
|
||||
# дата: 2026-10-31T01:03Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
# пять прогонов подряд: один удачный ничего не доказывает
|
||||
$ make upload-peak
|
||||
BASE_URL="http://localhost:8080" python3 scripts/upload_peak.py --output evidence/upload-peak.json
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 1, "file_bytes": 10481664, "seconds": 0.16, "slowest_upload_s": 0.16, "statuses": {"201": 1}, "memory": {"504924bd9076": {"process_peak_rss_mib": 117.0, "cgroup_peak_mib": 110.2}, "ec77c0e85d5c": {"process_peak_rss_mib": 117.0, "cgroup_peak_mib": 99.1}}}
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 10, "file_bytes": 10481664, "seconds": 1.53, "slowest_upload_s": 1.53, "statuses": {"201": 10}, "memory": {"504924bd9076": {"process_peak_rss_mib": 125.7, "cgroup_peak_mib": 165.9}, "ec77c0e85d5c": {"process_peak_rss_mib": 126.8, "cgroup_peak_mib": 156.3}}}
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 30, "file_bytes": 10481664, "seconds": 6.65, "slowest_upload_s": 6.64, "statuses": {"201": 30}, "memory": {"504924bd9076": {"process_peak_rss_mib": 128.6, "cgroup_peak_mib": 269.6}, "ec77c0e85d5c": {"process_peak_rss_mib": 130.5, "cgroup_peak_mib": 270.6}}}
|
||||
{"file": "прогрессивный CMYK JPEG, 40 млн пикселей", "parallel_uploads": 10, "file_bytes": 2642657, "seconds": 1.47, "slowest_upload_s": 1.47, "statuses": {"201": 10}, "memory": {"504924bd9076": {"process_peak_rss_mib": 438.0, "cgroup_peak_mib": 429.3}, "ec77c0e85d5c": {"process_peak_rss_mib": 439.9, "cgroup_peak_mib": 431.0}}}
|
||||
PASS: все загрузки успешны
|
||||
|
||||
$ make upload-peak
|
||||
BASE_URL="http://localhost:8080" python3 scripts/upload_peak.py --output evidence/upload-peak.json
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 1, "file_bytes": 10481664, "seconds": 0.16, "slowest_upload_s": 0.16, "statuses": {"201": 1}, "memory": {"504924bd9076": {"process_peak_rss_mib": 116.7, "cgroup_peak_mib": 98.5}, "ec77c0e85d5c": {"process_peak_rss_mib": 117.1, "cgroup_peak_mib": 109.0}}}
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 10, "file_bytes": 10481664, "seconds": 1.49, "slowest_upload_s": 1.49, "statuses": {"201": 10}, "memory": {"504924bd9076": {"process_peak_rss_mib": 123.6, "cgroup_peak_mib": 168.7}, "ec77c0e85d5c": {"process_peak_rss_mib": 123.7, "cgroup_peak_mib": 168.8}}}
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 30, "file_bytes": 10481664, "seconds": 4.89, "slowest_upload_s": 4.88, "statuses": {"201": 30}, "memory": {"504924bd9076": {"process_peak_rss_mib": 126.6, "cgroup_peak_mib": 269.3}, "ec77c0e85d5c": {"process_peak_rss_mib": 126.6, "cgroup_peak_mib": 269.6}}}
|
||||
{"file": "прогрессивный CMYK JPEG, 40 млн пикселей", "parallel_uploads": 10, "file_bytes": 2642657, "seconds": 1.42, "slowest_upload_s": 1.42, "statuses": {"201": 10}, "memory": {"504924bd9076": {"process_peak_rss_mib": 435.1, "cgroup_peak_mib": 426.9}, "ec77c0e85d5c": {"process_peak_rss_mib": 435.3, "cgroup_peak_mib": 427.2}}}
|
||||
PASS: все загрузки успешны
|
||||
|
||||
$ make upload-peak
|
||||
BASE_URL="http://localhost:8080" python3 scripts/upload_peak.py --output evidence/upload-peak.json
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 1, "file_bytes": 10481664, "seconds": 0.17, "slowest_upload_s": 0.17, "statuses": {"201": 1}, "memory": {"504924bd9076": {"process_peak_rss_mib": 117.1, "cgroup_peak_mib": 110.4}, "ec77c0e85d5c": {"process_peak_rss_mib": 117.0, "cgroup_peak_mib": 99.1}}}
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 10, "file_bytes": 10481664, "seconds": 1.6, "slowest_upload_s": 1.6, "statuses": {"201": 10}, "memory": {"504924bd9076": {"process_peak_rss_mib": 123.6, "cgroup_peak_mib": 161.2}, "ec77c0e85d5c": {"process_peak_rss_mib": 123.9, "cgroup_peak_mib": 163.2}}}
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 30, "file_bytes": 10481664, "seconds": 7.01, "slowest_upload_s": 7.0, "statuses": {"201": 30}, "memory": {"504924bd9076": {"process_peak_rss_mib": 129.6, "cgroup_peak_mib": 272.5}, "ec77c0e85d5c": {"process_peak_rss_mib": 130.0, "cgroup_peak_mib": 273.6}}}
|
||||
{"file": "прогрессивный CMYK JPEG, 40 млн пикселей", "parallel_uploads": 10, "file_bytes": 2642657, "seconds": 1.35, "slowest_upload_s": 1.35, "statuses": {"201": 10}, "memory": {"504924bd9076": {"process_peak_rss_mib": 438.4, "cgroup_peak_mib": 429.9}, "ec77c0e85d5c": {"process_peak_rss_mib": 438.9, "cgroup_peak_mib": 430.5}}}
|
||||
PASS: все загрузки успешны
|
||||
|
||||
$ make upload-peak
|
||||
BASE_URL="http://localhost:8080" python3 scripts/upload_peak.py --output evidence/upload-peak.json
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 1, "file_bytes": 10481664, "seconds": 0.15, "slowest_upload_s": 0.15, "statuses": {"201": 1}, "memory": {"504924bd9076": {"process_peak_rss_mib": 116.7, "cgroup_peak_mib": 110.2}, "ec77c0e85d5c": {"process_peak_rss_mib": 119.4, "cgroup_peak_mib": 112.6}}}
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 10, "file_bytes": 10481664, "seconds": 1.34, "slowest_upload_s": 1.33, "statuses": {"201": 10}, "memory": {"504924bd9076": {"process_peak_rss_mib": 123.6, "cgroup_peak_mib": 160.7}, "ec77c0e85d5c": {"process_peak_rss_mib": 123.9, "cgroup_peak_mib": 161.4}}}
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 30, "file_bytes": 10481664, "seconds": 7.19, "slowest_upload_s": 7.18, "statuses": {"201": 30}, "memory": {"504924bd9076": {"process_peak_rss_mib": 126.5, "cgroup_peak_mib": 266.8}, "ec77c0e85d5c": {"process_peak_rss_mib": 126.7, "cgroup_peak_mib": 267.5}}}
|
||||
{"file": "прогрессивный CMYK JPEG, 40 млн пикселей", "parallel_uploads": 10, "file_bytes": 2642657, "seconds": 1.31, "slowest_upload_s": 1.31, "statuses": {"201": 10}, "memory": {"504924bd9076": {"process_peak_rss_mib": 437.9, "cgroup_peak_mib": 429.2}, "ec77c0e85d5c": {"process_peak_rss_mib": 438.0, "cgroup_peak_mib": 429.1}}}
|
||||
PASS: все загрузки успешны
|
||||
|
||||
$ make upload-peak
|
||||
BASE_URL="http://localhost:8080" python3 scripts/upload_peak.py --output evidence/upload-peak.json
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 1, "file_bytes": 10481664, "seconds": 0.14, "slowest_upload_s": 0.14, "statuses": {"201": 1}, "memory": {"504924bd9076": {"process_peak_rss_mib": 117.2, "cgroup_peak_mib": 110.5}, "ec77c0e85d5c": {"process_peak_rss_mib": 116.6, "cgroup_peak_mib": 110.2}}}
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 10, "file_bytes": 10481664, "seconds": 2.1, "slowest_upload_s": 2.09, "statuses": {"201": 10}, "memory": {"504924bd9076": {"process_peak_rss_mib": 123.7, "cgroup_peak_mib": 166.6}, "ec77c0e85d5c": {"process_peak_rss_mib": 123.5, "cgroup_peak_mib": 160.5}}}
|
||||
{"file": "PNG 10 MiB", "parallel_uploads": 30, "file_bytes": 10481664, "seconds": 5.88, "slowest_upload_s": 5.88, "statuses": {"201": 30}, "memory": {"504924bd9076": {"process_peak_rss_mib": 128.8, "cgroup_peak_mib": 274.4}, "ec77c0e85d5c": {"process_peak_rss_mib": 128.3, "cgroup_peak_mib": 273.9}}}
|
||||
{"file": "прогрессивный CMYK JPEG, 40 млн пикселей", "parallel_uploads": 10, "file_bytes": 2642657, "seconds": 1.45, "slowest_upload_s": 1.44, "statuses": {"201": 10}, "memory": {"504924bd9076": {"process_peak_rss_mib": 437.6, "cgroup_peak_mib": 433.8}, "ec77c0e85d5c": {"process_peak_rss_mib": 437.3, "cgroup_peak_mib": 433.0}}}
|
||||
PASS: все загрузки успешны
|
||||
|
||||
# S3 за все прогоны: перезапуски и OOM
|
||||
restarts=0 oom=false
|
||||
oom 0
|
||||
oom_kill 0
|
||||
oom_group_kill 0
|
||||
# реплики API за все прогоны: OOM
|
||||
restarts=0 oom=false
|
||||
oom_kill 0
|
||||
restarts=0 oom=false
|
||||
oom_kill 0
|
||||
@@ -0,0 +1,93 @@
|
||||
# Контейнеры: лимиты, порты, сети, секреты, права ключа S3
|
||||
# дата: 2026-10-31T01:05Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
$ docker compose ps # опубликован только lb, консоль S3 наружу не открыта
|
||||
SERVICE PORTS
|
||||
api 8080/tcp
|
||||
api 8080/tcp
|
||||
janitor 8080/tcp
|
||||
lb 127.0.0.1:8080->8080/tcp
|
||||
postgres 5432/tcp
|
||||
redis 6379/tcp
|
||||
s3 7333/tcp, 8080/tcp, 8333/tcp, 8888/tcp, 9333/tcp, 18080/tcp, 18888/tcp, 19333/tcp
|
||||
|
||||
$ grep -c container_name compose.yaml
|
||||
0
|
||||
|
||||
# лимиты CPU (в наносекундах на секунду) и памяти (байт)
|
||||
/mtusi-messenger-lab4-api-3 cpus=1000000000 memory=536870912
|
||||
/mtusi-messenger-lab4-api-4 cpus=1000000000 memory=536870912
|
||||
/mtusi-messenger-lab4-janitor-1 cpus=250000000 memory=134217728
|
||||
/mtusi-messenger-lab4-lb-1 cpus=500000000 memory=134217728
|
||||
/mtusi-messenger-lab4-postgres-1 cpus=1000000000 memory=536870912
|
||||
/mtusi-messenger-lab4-redis-1 cpus=500000000 memory=134217728
|
||||
/mtusi-messenger-lab4-s3-1 cpus=1000000000 memory=1073741824
|
||||
|
||||
# сети
|
||||
lb mtusi-messenger-lab4_edge
|
||||
api mtusi-messenger-lab4_data mtusi-messenger-lab4_edge mtusi-messenger-lab4_storage
|
||||
janitor mtusi-messenger-lab4_data mtusi-messenger-lab4_storage
|
||||
s3 mtusi-messenger-lab4_storage
|
||||
postgres mtusi-messenger-lab4_data
|
||||
redis mtusi-messenger-lab4_data
|
||||
|
||||
$ docker exec 504924bd9076 id
|
||||
uid=10001(app) gid=10001(app) groups=10001(app)
|
||||
|
||||
$ docker exec <api> ls /run/secrets # ключа администратора S3 у API нет
|
||||
cache_url
|
||||
database_url
|
||||
s3_access_key_id
|
||||
s3_secret_access_key
|
||||
|
||||
$ docker exec <api> env | grep -ci "password\|postgresql://\|redis://"
|
||||
0
|
||||
|
||||
$ docker compose --env-file .env images
|
||||
CONTAINER REPOSITORY TAG PLATFORM IMAGE ID SIZE CREATED
|
||||
mtusi-messenger-lab4-api-3 mtusi-messenger lab4 linux/arm64 e71bfdb1c725 252MB 22 minutes ago
|
||||
mtusi-messenger-lab4-api-4 mtusi-messenger lab4 linux/arm64 e71bfdb1c725 252MB 22 minutes ago
|
||||
mtusi-messenger-lab4-janitor-1 sha256 53d2e279c4c191e566b6dd52082c532a7a4c5bb9f9ee75cd2c8327a3bc8f5944 linux/arm64 53d2e279c4c1 252MB 22 minutes ago
|
||||
mtusi-messenger-lab4-lb-1 mtusi-messenger-lb lab4 linux/arm64 874b8c49635f 38.8MB 5 hours ago
|
||||
mtusi-messenger-lab4-migrate-1 sha256 53d2e279c4c191e566b6dd52082c532a7a4c5bb9f9ee75cd2c8327a3bc8f5944 linux/arm64 53d2e279c4c1 252MB 22 minutes ago
|
||||
mtusi-messenger-lab4-postgres-1 postgres 17.11-alpine linux/arm64/v8 25a89970a832 291MB 6 weeks ago
|
||||
mtusi-messenger-lab4-redis-1 redis 7.4.11-alpine linux/arm64/v8 ec4f171e9ff0 39.5MB 6 weeks ago
|
||||
mtusi-messenger-lab4-s3-1 mtusi-messenger-s3 lab4 linux/arm64 bb740ce2c254 509MB 5 hours ago
|
||||
mtusi-messenger-lab4-s3-init-1 sha256 53d2e279c4c191e566b6dd52082c532a7a4c5bb9f9ee75cd2c8327a3bc8f5944 linux/arm64 53d2e279c4c1 252MB 22 minutes ago
|
||||
|
||||
$ docker exec <api> pip freeze
|
||||
annotated-doc==0.0.5
|
||||
annotated-types==0.8.0
|
||||
anyio==4.15.1
|
||||
argon2-cffi==25.1.0
|
||||
argon2-cffi-bindings==26.1.0
|
||||
boto3==1.43.122
|
||||
botocore==1.43.122
|
||||
cffi==2.1.1
|
||||
click==8.5.0
|
||||
fastapi==0.143.0
|
||||
h11==0.16.0
|
||||
idna==3.20
|
||||
jmespath==1.1.0
|
||||
opentelemetry-api==1.45.1
|
||||
pillow==13.0.0
|
||||
psycopg==3.3.6
|
||||
psycopg-binary==3.3.6
|
||||
psycopg-pool==3.3.3
|
||||
pycparser==3.1
|
||||
pydantic==2.13.5
|
||||
pydantic_core==2.46.5
|
||||
python-dateutil==2.9.0.post0
|
||||
redis==8.1.0
|
||||
s3transfer==0.19.3
|
||||
six==1.17.0
|
||||
starlette==1.7.0
|
||||
typing-inspection==0.4.4
|
||||
typing_extensions==4.16.0
|
||||
urllib3==2.8.0
|
||||
uvicorn==0.54.0
|
||||
|
||||
$ git ls-files | grep -E "^\.env$|secrets" # в Git секретов нет
|
||||
(пусто)
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
# SIGTERM через балансировщик
|
||||
# дата: 2026-10-31T01:05Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
$ python3 scripts/sigterm_check.py
|
||||
$ docker kill --signal=SIGTERM 504924bd9076
|
||||
новых запросов после SIGTERM: 20, попало на останавливаемую реплику: 0
|
||||
начатые до SIGTERM запросы: ['HTTP/1.1 201 Created']
|
||||
из них завершила останавливаемая реплика: 3
|
||||
процесс завершился за 1.57 с, код выхода 0
|
||||
PASS: остановка корректная и укладывается в 10 секунд
|
||||
|
||||
@@ -0,0 +1,128 @@
|
||||
# Индекс истории: EXPLAIN (ANALYZE, BUFFERS), объём данных в первой таблице вывода
|
||||
# дата: 2026-10-31T01:05Z, чистый clone
|
||||
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
|
||||
|
||||
$ make explain
|
||||
./scripts/explain_history.sh
|
||||
== Объём данных
|
||||
messages_total | messages_in_chat | table_size | index_size
|
||||
----------------+------------------+------------+------------
|
||||
91163 | 10000 | 10120 kB | 8968 kB
|
||||
(1 row)
|
||||
|
||||
|
||||
== 1. Первая страница (limit 50, запрос берёт 51 строку)
|
||||
QUERY PLAN
|
||||
------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.42..726.39 rows=51 width=112) (actual time=0.031..0.253 rows=51 loops=1)
|
||||
Buffers: shared hit=64
|
||||
-> Index Scan using messages_chat_history_idx on messages (cost=0.42..145123.89 rows=10195 width=112) (actual time=0.031..0.249 rows=51 loops=1)
|
||||
Index Cond: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid)
|
||||
Buffers: shared hit=64
|
||||
SubPlan 1
|
||||
-> Aggregate (cost=13.78..13.79 rows=1 width=32) (actual time=0.004..0.004 rows=1 loops=51)
|
||||
Buffers: shared hit=54
|
||||
-> Sort (cost=13.74..13.76 rows=6 width=20) (actual time=0.003..0.003 rows=0 loops=51)
|
||||
Sort Key: a."position"
|
||||
Sort Method: quicksort Memory: 25kB
|
||||
Buffers: shared hit=54
|
||||
-> Bitmap Heap Scan on message_attachments a (cost=4.20..13.67 rows=6 width=20) (actual time=0.000..0.000 rows=0 loops=51)
|
||||
Recheck Cond: (message_id = messages.id)
|
||||
Buffers: shared hit=51
|
||||
-> Bitmap Index Scan on message_attachments_pkey (cost=0.00..4.20 rows=6 width=0) (actual time=0.000..0.000 rows=0 loops=51)
|
||||
Index Cond: (message_id = messages.id)
|
||||
Buffers: shared hit=51
|
||||
Planning:
|
||||
Buffers: shared hit=78
|
||||
Planning Time: 0.235 ms
|
||||
Execution Time: 0.286 ms
|
||||
(22 rows)
|
||||
|
||||
|
||||
== 2. Страница из середины истории: keyset после 5000-го сообщения
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.42..735.98 rows=51 width=112) (actual time=0.017..0.251 rows=51 loops=1)
|
||||
Buffers: shared hit=59
|
||||
-> Index Scan using messages_chat_history_idx on messages (cost=0.42..98594.86 rows=6836 width=112) (actual time=0.017..0.248 rows=51 loops=1)
|
||||
Index Cond: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 16:45:29.612108+00'::timestamp with time zone, '6dacd396-f0bd-431e-8871-9e3bb7792539'::uuid)))
|
||||
Buffers: shared hit=59
|
||||
SubPlan 1
|
||||
-> Aggregate (cost=13.78..13.79 rows=1 width=32) (actual time=0.004..0.004 rows=1 loops=51)
|
||||
Buffers: shared hit=51
|
||||
-> Sort (cost=13.74..13.76 rows=6 width=20) (actual time=0.003..0.003 rows=0 loops=51)
|
||||
Sort Key: a."position"
|
||||
Sort Method: quicksort Memory: 25kB
|
||||
Buffers: shared hit=51
|
||||
-> Bitmap Heap Scan on message_attachments a (cost=4.20..13.67 rows=6 width=20) (actual time=0.000..0.000 rows=0 loops=51)
|
||||
Recheck Cond: (message_id = messages.id)
|
||||
Buffers: shared hit=51
|
||||
-> Bitmap Index Scan on message_attachments_pkey (cost=0.00..4.20 rows=6 width=0) (actual time=0.000..0.000 rows=0 loops=51)
|
||||
Index Cond: (message_id = messages.id)
|
||||
Buffers: shared hit=51
|
||||
Planning Time: 0.052 ms
|
||||
Execution Time: 0.291 ms
|
||||
(20 rows)
|
||||
|
||||
|
||||
== 3. Та же страница через OFFSET (так делать не стали)
|
||||
QUERY PLAN
|
||||
--------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=71174.26..71900.24 rows=51 width=112) (actual time=6.185..6.246 rows=51 loops=1)
|
||||
Buffers: shared hit=5551
|
||||
-> Index Scan using messages_chat_history_idx on messages (cost=0.42..145123.89 rows=10195 width=112) (actual time=0.012..6.130 rows=5051 loops=1)
|
||||
Index Cond: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid)
|
||||
Buffers: shared hit=5551
|
||||
SubPlan 1
|
||||
-> Aggregate (cost=13.78..13.79 rows=1 width=32) (actual time=0.001..0.001 rows=1 loops=5051)
|
||||
Buffers: shared hit=5051
|
||||
-> Sort (cost=13.74..13.76 rows=6 width=20) (actual time=0.001..0.001 rows=0 loops=5051)
|
||||
Sort Key: a."position"
|
||||
Sort Method: quicksort Memory: 25kB
|
||||
Buffers: shared hit=5051
|
||||
-> Bitmap Heap Scan on message_attachments a (cost=4.20..13.67 rows=6 width=20) (actual time=0.000..0.000 rows=0 loops=5051)
|
||||
Recheck Cond: (message_id = messages.id)
|
||||
Buffers: shared hit=5051
|
||||
-> Bitmap Index Scan on message_attachments_pkey (cost=0.00..4.20 rows=6 width=0) (actual time=0.000..0.000 rows=0 loops=5051)
|
||||
Index Cond: (message_id = messages.id)
|
||||
Buffers: shared hit=5051
|
||||
Planning Time: 0.038 ms
|
||||
Execution Time: 6.266 ms
|
||||
(20 rows)
|
||||
|
||||
|
||||
== 4. Запрос из пункта 2 без индекса messages_chat_history_idx (DROP INDEX внутри транзакции с ROLLBACK)
|
||||
QUERY PLAN
|
||||
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=3088.42..3792.21 rows=51 width=112) (actual time=3.362..3.425 rows=51 loops=1)
|
||||
Buffers: shared hit=1322
|
||||
-> Result (cost=3088.42..97424.85 rows=6836 width=112) (actual time=3.362..3.422 rows=51 loops=1)
|
||||
Buffers: shared hit=1322
|
||||
-> Sort (cost=3088.42..3105.51 rows=6836 width=80) (actual time=3.343..3.345 rows=51 loops=1)
|
||||
Sort Key: messages.created_at, messages.id
|
||||
Sort Method: top-N heapsort Memory: 31kB
|
||||
Buffers: shared hit=1271
|
||||
-> Seq Scan on messages (cost=0.00..2860.35 rows=6836 width=80) (actual time=1.866..3.076 rows=5000 loops=1)
|
||||
Filter: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 16:45:29.612108+00'::timestamp with time zone, '6dacd396-f0bd-431e-8871-9e3bb7792539'::uuid)))
|
||||
Rows Removed by Filter: 86163
|
||||
Buffers: shared hit=1265
|
||||
SubPlan 1
|
||||
-> Aggregate (cost=13.78..13.79 rows=1 width=32) (actual time=0.001..0.001 rows=1 loops=51)
|
||||
Buffers: shared hit=51
|
||||
-> Sort (cost=13.74..13.76 rows=6 width=20) (actual time=0.001..0.001 rows=0 loops=51)
|
||||
Sort Key: a."position"
|
||||
Sort Method: quicksort Memory: 25kB
|
||||
Buffers: shared hit=51
|
||||
-> Bitmap Heap Scan on message_attachments a (cost=4.20..13.67 rows=6 width=20) (actual time=0.000..0.000 rows=0 loops=51)
|
||||
Recheck Cond: (message_id = messages.id)
|
||||
Buffers: shared hit=51
|
||||
-> Bitmap Index Scan on message_attachments_pkey (cost=0.00..4.20 rows=6 width=0) (actual time=0.000..0.000 rows=0 loops=51)
|
||||
Index Cond: (message_id = messages.id)
|
||||
Buffers: shared hit=51
|
||||
Planning:
|
||||
Buffers: shared hit=4
|
||||
Planning Time: 0.057 ms
|
||||
Execution Time: 3.455 ms
|
||||
(29 rows)
|
||||
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
{
|
||||
"workload": "4 клиента, closed loop, POST сообщений через балансировщик, повтор с тем же ключом",
|
||||
"mode": "stop",
|
||||
"rounds": [
|
||||
{
|
||||
"seconds": 18.19,
|
||||
"successful_requests": 8333,
|
||||
"failed_attempts": 0,
|
||||
"failed_statuses": [],
|
||||
"successful_rps": 458.1,
|
||||
"longest_gap_between_successes_s": 0.997,
|
||||
"first_success_after_action_s": 0.004,
|
||||
"last_success_on_target_after_action_s": 13.188,
|
||||
"instances_seen": 2,
|
||||
"target": "e0ce1c223b49",
|
||||
"signal": "SIGTERM",
|
||||
"stop_command_s": 0.59,
|
||||
"excluded_by_lb_after_s": 1.63,
|
||||
"verify": {
|
||||
"confirmed": 8333,
|
||||
"in_history": 8333,
|
||||
"lost_confirmed": 0,
|
||||
"duplicate_ids": 0,
|
||||
"duplicate_texts": 0,
|
||||
"unconfirmed_but_saved": 0
|
||||
}
|
||||
},
|
||||
{
|
||||
"seconds": 19.85,
|
||||
"successful_requests": 9258,
|
||||
"failed_attempts": 1,
|
||||
"failed_statuses": [
|
||||
502
|
||||
],
|
||||
"successful_rps": 466.3,
|
||||
"longest_gap_between_successes_s": 1.016,
|
||||
"first_success_after_action_s": 0.005,
|
||||
"last_success_on_target_after_action_s": 14.853,
|
||||
"instances_seen": 2,
|
||||
"target": "6e7001b3af3a",
|
||||
"signal": "SIGTERM",
|
||||
"stop_command_s": 0.66,
|
||||
"excluded_by_lb_after_s": 0.78,
|
||||
"verify": {
|
||||
"confirmed": 9258,
|
||||
"in_history": 9258,
|
||||
"lost_confirmed": 0,
|
||||
"duplicate_ids": 0,
|
||||
"duplicate_texts": 0,
|
||||
"unconfirmed_but_saved": 0
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
{
|
||||
"workload": "4 клиента, closed loop, POST сообщений через балансировщик, повтор с тем же ключом",
|
||||
"mode": "rolling",
|
||||
"rounds": [
|
||||
{
|
||||
"seconds": 24.77,
|
||||
"successful_requests": 13125,
|
||||
"failed_attempts": 0,
|
||||
"failed_statuses": [],
|
||||
"successful_rps": 529.8,
|
||||
"longest_gap_between_successes_s": 0.995,
|
||||
"first_success_after_action_s": 0.0,
|
||||
"last_success_on_target_after_action_s": null,
|
||||
"instances_seen": 4,
|
||||
"update_seconds": 14.77,
|
||||
"containers_before": {
|
||||
"e0ce1c223b49": "sha256:53d2e279c4c1",
|
||||
"6e7001b3af3a": "sha256:53d2e279c4c1"
|
||||
},
|
||||
"containers_after": {
|
||||
"504924bd9076": "sha256:e71bfdb1c725",
|
||||
"ec77c0e85d5c": "sha256:e71bfdb1c725"
|
||||
},
|
||||
"app_version": "2",
|
||||
"verify": {
|
||||
"confirmed": 13125,
|
||||
"in_history": 13125,
|
||||
"lost_confirmed": 0,
|
||||
"duplicate_ids": 0,
|
||||
"duplicate_texts": 0,
|
||||
"unconfirmed_but_saved": 0
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
{
|
||||
"limit_per_replica_mib": 512,
|
||||
"replicas": 2,
|
||||
"levels": [
|
||||
{
|
||||
"parallel_uploads": 0,
|
||||
"memory": {
|
||||
"504924bd9076": {
|
||||
"process_peak_rss_mib": 116.8,
|
||||
"cgroup_peak_mib": 110.5
|
||||
},
|
||||
"ec77c0e85d5c": {
|
||||
"process_peak_rss_mib": 116.6,
|
||||
"cgroup_peak_mib": 110.2
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"file": "PNG 10 MiB",
|
||||
"parallel_uploads": 1,
|
||||
"file_bytes": 10481664,
|
||||
"seconds": 0.14,
|
||||
"slowest_upload_s": 0.14,
|
||||
"statuses": {
|
||||
"201": 1
|
||||
},
|
||||
"memory": {
|
||||
"504924bd9076": {
|
||||
"process_peak_rss_mib": 117.2,
|
||||
"cgroup_peak_mib": 110.5
|
||||
},
|
||||
"ec77c0e85d5c": {
|
||||
"process_peak_rss_mib": 116.6,
|
||||
"cgroup_peak_mib": 110.2
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"file": "PNG 10 MiB",
|
||||
"parallel_uploads": 10,
|
||||
"file_bytes": 10481664,
|
||||
"seconds": 2.1,
|
||||
"slowest_upload_s": 2.09,
|
||||
"statuses": {
|
||||
"201": 10
|
||||
},
|
||||
"memory": {
|
||||
"504924bd9076": {
|
||||
"process_peak_rss_mib": 123.7,
|
||||
"cgroup_peak_mib": 166.6
|
||||
},
|
||||
"ec77c0e85d5c": {
|
||||
"process_peak_rss_mib": 123.5,
|
||||
"cgroup_peak_mib": 160.5
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"file": "PNG 10 MiB",
|
||||
"parallel_uploads": 30,
|
||||
"file_bytes": 10481664,
|
||||
"seconds": 5.88,
|
||||
"slowest_upload_s": 5.88,
|
||||
"statuses": {
|
||||
"201": 30
|
||||
},
|
||||
"memory": {
|
||||
"504924bd9076": {
|
||||
"process_peak_rss_mib": 128.8,
|
||||
"cgroup_peak_mib": 274.4
|
||||
},
|
||||
"ec77c0e85d5c": {
|
||||
"process_peak_rss_mib": 128.3,
|
||||
"cgroup_peak_mib": 273.9
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"file": "прогрессивный CMYK JPEG, 40 млн пикселей",
|
||||
"parallel_uploads": 10,
|
||||
"file_bytes": 2642657,
|
||||
"seconds": 1.45,
|
||||
"slowest_upload_s": 1.44,
|
||||
"statuses": {
|
||||
"201": 10
|
||||
},
|
||||
"memory": {
|
||||
"504924bd9076": {
|
||||
"process_peak_rss_mib": 437.6,
|
||||
"cgroup_peak_mib": 433.8
|
||||
},
|
||||
"ec77c0e85d5c": {
|
||||
"process_peak_rss_mib": 437.3,
|
||||
"cgroup_peak_mib": 433.0
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
FROM haproxy:3.2.26-alpine
|
||||
|
||||
# конфигурация внутри образа: версия балансировщика и его настройки меняются только сборкой
|
||||
COPY haproxy.cfg /usr/local/etc/haproxy/haproxy.cfg
|
||||
COPY errors/ /usr/local/etc/haproxy/errors/
|
||||
|
||||
RUN ["haproxy", "-c", "-f", "/usr/local/etc/haproxy/haproxy.cfg"]
|
||||
@@ -0,0 +1,8 @@
|
||||
HTTP/1.1 400 Bad Request
|
||||
Content-Type: application/json
|
||||
Content-Length: 119
|
||||
Cache-Control: no-cache
|
||||
Connection: close
|
||||
X-Request-Id: lb-400
|
||||
|
||||
{"error": {"code": "invalid_request", "message": "Некорректный HTTP-запрос", "request_id": "lb-400"}}
|
||||
@@ -0,0 +1,8 @@
|
||||
HTTP/1.1 408 Request Timeout
|
||||
Content-Type: application/json
|
||||
Content-Length: 124
|
||||
Cache-Control: no-cache
|
||||
Connection: close
|
||||
X-Request-Id: lb-408
|
||||
|
||||
{"error": {"code": "invalid_request", "message": "Запрос не получен вовремя", "request_id": "lb-408"}}
|
||||
@@ -0,0 +1,8 @@
|
||||
HTTP/1.1 414 URI Too Long
|
||||
Content-Type: application/json
|
||||
Content-Length: 132
|
||||
Cache-Control: no-cache
|
||||
Connection: close
|
||||
X-Request-Id: lb-414
|
||||
|
||||
{"error": {"code": "invalid_request", "message": "Слишком длинный адрес запроса", "request_id": "lb-414"}}
|
||||
@@ -0,0 +1,8 @@
|
||||
HTTP/1.1 431 Request Header Fields Too Large
|
||||
Content-Type: application/json
|
||||
Content-Length: 140
|
||||
Cache-Control: no-cache
|
||||
Connection: close
|
||||
X-Request-Id: lb-431
|
||||
|
||||
{"error": {"code": "invalid_request", "message": "Слишком большие заголовки запроса", "request_id": "lb-431"}}
|
||||
@@ -0,0 +1,71 @@
|
||||
global
|
||||
log stdout format raw local0 info
|
||||
maxconn 2000
|
||||
|
||||
defaults
|
||||
mode http
|
||||
log global
|
||||
# в лог не попадают query string и заголовки: только путь, код, тайминги и выбранный сервер
|
||||
log-format "%ci %HM %HPO status=%ST server=%s retries=%rc Tq=%TR Tw=%Tw Tc=%Tc Tr=%Tr Ta=%Ta"
|
||||
# новое соединение с API на каждый запрос: остановленная реплика сразу видна как отказ соединения,
|
||||
# а такой запрос до приложения не дошёл, поэтому его безопасно отправить на другую
|
||||
option http-server-close
|
||||
retries 2
|
||||
retry-on conn-failure
|
||||
option redispatch 1
|
||||
timeout connect 1s
|
||||
timeout http-request 10s
|
||||
timeout queue 3s
|
||||
# больше самого долгого ответа API: очередь на запись 10 с + S3 7 с + база и Redis по 1-2 с
|
||||
timeout server 20s
|
||||
timeout client 30s
|
||||
timeout http-keep-alive 30s
|
||||
timeout check 1s
|
||||
# запрос, который не удалось разобрать: своего id у него ещё нет, поэтому ответы готовые, в формате контракта
|
||||
errorfile 400 /usr/local/etc/haproxy/errors/400.http
|
||||
errorfile 408 /usr/local/etc/haproxy/errors/408.http
|
||||
errorfile 414 /usr/local/etc/haproxy/errors/414.http
|
||||
errorfile 431 /usr/local/etc/haproxy/errors/431.http
|
||||
|
||||
resolvers docker
|
||||
nameserver dns 127.0.0.11:53
|
||||
accepted_payload_size 8192
|
||||
# DNS Docker убирает остановленные контейнеры и добавляет новые, список реплик обновляется сам
|
||||
timeout resolve 1s
|
||||
timeout retry 1s
|
||||
hold valid 2s
|
||||
hold obsolete 0s
|
||||
hold nx 2s
|
||||
|
||||
frontend api_in
|
||||
bind *:8080
|
||||
unique-id-format %[uuid(4)]
|
||||
# грубый предел до API: файл 10 MiB проходит, точный лимит считает приложение
|
||||
http-request deny deny_status 413 if { req.hdr_val(content-length) gt 11534336 }
|
||||
default_backend api
|
||||
|
||||
# ответы самого балансировщика в формате ошибок контракта
|
||||
http-error status 413 content-type application/json lf-string '{"error":{"code":"payload_too_large","message":"Слишком большое тело запроса","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
|
||||
http-error status 500 content-type application/json lf-string '{"error":{"code":"internal_error","message":"Внутренняя ошибка сервера","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
|
||||
http-error status 502 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
|
||||
http-error status 503 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
|
||||
http-error status 504 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
|
||||
|
||||
backend api
|
||||
balance roundrobin
|
||||
# без sticky session: любой запрос может уйти на любую реплику
|
||||
option httpchk GET /health/ready
|
||||
http-check expect status 200
|
||||
# проверка раз в секунду, две неудачи подряд исключают реплику, две удачи возвращают
|
||||
default-server check inter 1s fall 2 rise 2 resolvers docker resolve-prefer ipv4 init-addr none
|
||||
# до 6 реплик; адреса приходят из DNS по имени сервиса
|
||||
server-template api 1-6 api:8080
|
||||
|
||||
# только внутри контейнера lb, порт не опубликован
|
||||
frontend internal
|
||||
bind *:8404
|
||||
monitor-uri /lb-health
|
||||
stats enable
|
||||
stats uri /stats
|
||||
stats refresh 0
|
||||
no log
|
||||
@@ -0,0 +1,5 @@
|
||||
FROM chrislusf/seaweedfs:4.50
|
||||
|
||||
COPY start.sh /usr/local/bin/start-s3.sh
|
||||
|
||||
ENTRYPOINT ["/usr/local/bin/start-s3.sh"]
|
||||
Executable
+35
@@ -0,0 +1,35 @@
|
||||
#!/bin/sh
|
||||
# Собирает конфигурацию ключей из секретов и запускает SeaweedFS. Анонимного доступа нет:
|
||||
# запрос без подписи одного из этих ключей отклоняется, поэтому bucket приватный.
|
||||
set -eu
|
||||
|
||||
secret() { cat "/run/secrets/$1"; }
|
||||
bucket=${S3_BUCKET:-messenger-attachments}
|
||||
|
||||
umask 077
|
||||
cat > /tmp/s3.json <<JSON
|
||||
{
|
||||
"identities": [
|
||||
{
|
||||
"name": "admin",
|
||||
"credentials": [{"accessKey": "$(secret s3_admin_access_key_id)", "secretKey": "$(secret s3_admin_secret_access_key)"}],
|
||||
"actions": ["Admin"]
|
||||
},
|
||||
{
|
||||
"name": "api",
|
||||
"credentials": [{"accessKey": "$(secret s3_access_key_id)", "secretKey": "$(secret s3_secret_access_key)"}],
|
||||
"actions": ["Read:$bucket", "Write:$bucket"]
|
||||
},
|
||||
{
|
||||
"name": "janitor",
|
||||
"credentials": [{"accessKey": "$(secret s3_janitor_access_key_id)", "secretKey": "$(secret s3_janitor_secret_access_key)"}],
|
||||
"actions": ["List:$bucket", "Write:$bucket"]
|
||||
}
|
||||
]
|
||||
}
|
||||
JSON
|
||||
chown seaweed:seaweed /tmp/s3.json
|
||||
|
||||
exec /entrypoint.sh server -dir=/data -ip=s3 -ip.bind=0.0.0.0 \
|
||||
-master.volumeSizeLimitMB=256 -volume.max=100 \
|
||||
-s3 -s3.port=9000 -s3.config=/tmp/s3.json
|
||||
@@ -0,0 +1,39 @@
|
||||
-- Пользователи, чаты, участники и сообщения.
|
||||
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
-- порядок участника в исходном запросе, чтобы member_ids возвращались как были переданы
|
||||
position integer NOT NULL,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
-- список чатов пользователя: поиск по user_id, первичный ключ начинается с chat_id и для этого не подходит
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
sender_id uuid NOT NULL REFERENCES users (id),
|
||||
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
-- история чата читается запросом
|
||||
-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT $4
|
||||
-- индекс в том же порядке даёт и фильтр, и сортировку без чтения всей истории
|
||||
CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1,12 @@
|
||||
-- Результат отправки сообщения по Idempotency-Key. Только новая таблица: версия API без неё продолжает работать.
|
||||
|
||||
CREATE TABLE idempotency_keys (
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
key text NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'),
|
||||
-- проверка отложена до COMMIT: ключ вставляется раньше сообщения, чтобы занять его первым
|
||||
message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
-- область уникальности из контракта: пользователь + метод + путь чата + ключ
|
||||
PRIMARY KEY (user_id, chat_id, key)
|
||||
);
|
||||
@@ -0,0 +1,31 @@
|
||||
-- Вложения: метаданные здесь, байты в S3. Только добавления: версия API без вложений продолжает работать.
|
||||
|
||||
-- сообщение с вложением может быть без текста
|
||||
ALTER TABLE messages DROP CONSTRAINT messages_text_check;
|
||||
ALTER TABLE messages ADD CONSTRAINT messages_text_check 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),
|
||||
filename text NOT NULL CHECK (char_length(filename) BETWEEN 1 AND 255),
|
||||
content_type text NOT NULL CHECK (content_type IN ('image/png', 'image/jpeg')),
|
||||
size_bytes bigint NOT NULL CHECK (size_bytes BETWEEN 1 AND 10485760),
|
||||
sha256 text NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'),
|
||||
-- ключ назначает сервер, имя файла в нём не участвует
|
||||
object_key text NOT NULL UNIQUE,
|
||||
-- pending: строка записана, объект в S3 может ещё не появиться; наружу такие вложения не видны
|
||||
state text NOT NULL CHECK (state IN ('pending', 'ready')),
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
updated_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
-- janitor ищет незавершённые загрузки; таких строк мало, поэтому индекс частичный
|
||||
CREATE INDEX attachments_pending_idx ON attachments (created_at) WHERE state = 'pending';
|
||||
|
||||
CREATE TABLE message_attachments (
|
||||
message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE,
|
||||
attachment_id uuid NOT NULL REFERENCES attachments (id),
|
||||
position integer NOT NULL,
|
||||
PRIMARY KEY (message_id, attachment_id)
|
||||
);
|
||||
@@ -0,0 +1,32 @@
|
||||
# Прямые зависимости
|
||||
fastapi==0.143.0
|
||||
uvicorn==0.54.0
|
||||
psycopg[binary,pool]==3.3.6
|
||||
redis==8.1.0
|
||||
argon2-cffi==25.1.0
|
||||
boto3==1.43.122
|
||||
pillow==13.0.0
|
||||
# Транзитивные, зафиксированы по pip freeze в python:3.13.16-slim-bookworm
|
||||
annotated-doc==0.0.5
|
||||
annotated-types==0.8.0
|
||||
anyio==4.15.1
|
||||
argon2-cffi-bindings==26.1.0
|
||||
botocore==1.43.122
|
||||
cffi==2.1.1
|
||||
click==8.5.0
|
||||
h11==0.16.0
|
||||
idna==3.20
|
||||
jmespath==1.1.0
|
||||
opentelemetry-api==1.45.1
|
||||
psycopg-binary==3.3.6
|
||||
psycopg-pool==3.3.3
|
||||
pycparser==3.1
|
||||
pydantic==2.13.5
|
||||
pydantic_core==2.46.5
|
||||
python-dateutil==2.9.0.post0
|
||||
s3transfer==0.19.3
|
||||
six==1.17.0
|
||||
starlette==1.7.0
|
||||
typing-inspection==0.4.4
|
||||
typing_extensions==4.16.0
|
||||
urllib3==2.8.0
|
||||
Executable
+23
@@ -0,0 +1,23 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Сценарий защиты: файл, сообщение, чужой пользователь, прямой доступ к S3. Запускать из корня репозитория."""
|
||||
import hashlib
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, "student-tests")
|
||||
from api import call, new_chat, new_user, request_bytes, send
|
||||
data = Path("tests/fixtures/sample.png").read_bytes()
|
||||
alice, bob, eve = new_user("alice"), new_user("bob"), new_user("eve")
|
||||
chat = new_chat(alice, bob)
|
||||
_, att, _ = call("POST", "/api/v1/chats/%s/attachments?filename=sample.png" % chat["id"], raw=data, user=alice, headers={"Content-Type": "image/png"})
|
||||
print("загрузка:", att["status"], att["size_bytes"], "байт, sha256", att["sha256"][:16])
|
||||
status, msg, _ = send(alice, chat, "смотри файл", attachment_ids=[att["id"]])
|
||||
print("сообщение:", status, "attachment_ids =", len(msg["attachment_ids"]))
|
||||
status, body, headers = request_bytes("GET", "/api/v1/attachments/%s/content" % att["id"], user=bob)
|
||||
print("второй участник скачал:", status, headers.get_content_type(), "sha256 совпал:", hashlib.sha256(body).hexdigest() == hashlib.sha256(data).hexdigest())
|
||||
print("посторонний, метаданные:", call("GET", "/api/v1/attachments/" + att["id"], user=eve)[0], " байты:", request_bytes("GET", "/api/v1/attachments/%s/content" % att["id"], user=eve)[0])
|
||||
code = "import urllib.request,urllib.error\ntry:\n print(urllib.request.urlopen('http://s3:9000/messenger-attachments/originals/%s',timeout=3).status)\nexcept urllib.error.HTTPError as e:\n print(e.code)" % att["id"]
|
||||
cid = subprocess.run(["docker","compose","--env-file",".env","ps","-q","api"],capture_output=True,text=True).stdout.split()[0]
|
||||
out = subprocess.run(["docker","exec",cid,"python","-c",code],capture_output=True,text=True).stdout.strip()
|
||||
print("прямой GET в S3 без подписи изнутри сети:", out)
|
||||
@@ -0,0 +1,245 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Нагрузка записью через балансировщик во время отказа или замены реплик.
|
||||
|
||||
stop — по очереди останавливает каждую реплику (SIGTERM), восстанавливая предыдущую;
|
||||
kill — то же, но SIGKILL, без корректного завершения;
|
||||
pause — то же, но реплика зависает (docker pause): соединения открыты, ответов нет;
|
||||
rolling — запускает scripts/rolling-update.sh.
|
||||
|
||||
Клиент ведёт себя как в контракте: при неопределённом ответе повторяет запрос с тем же ключом.
|
||||
В конце вся история сверяется с подтверждёнными сообщениями.
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "student-tests"))
|
||||
from api import call, history, new_chat, new_user, send
|
||||
|
||||
WORKERS = 4
|
||||
|
||||
|
||||
def compose(*args):
|
||||
command = ["docker", "compose", "--env-file", ".env", *args]
|
||||
return subprocess.run(command, cwd=ROOT, check=True, capture_output=True, text=True).stdout
|
||||
|
||||
|
||||
def api_containers():
|
||||
return compose("ps", "-q", "api").split()
|
||||
|
||||
|
||||
def wait_ready(seconds=60):
|
||||
deadline = time.monotonic() + seconds
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
if call("GET", "/health/ready", timeout=2)[0] == 200:
|
||||
return
|
||||
except OSError:
|
||||
pass
|
||||
time.sleep(0.2)
|
||||
raise SystemExit("стенд не стал готов")
|
||||
|
||||
|
||||
def wait_replicas(count):
|
||||
"""Ждёт, пока балансировщик начнёт отдавать запросы на count разных реплик."""
|
||||
deadline = time.monotonic() + 30
|
||||
while time.monotonic() < deadline:
|
||||
seen = {call("GET", "/health/live", timeout=2)[2]["X-Instance-Id"] for _ in range(count * 4)}
|
||||
if len(seen) >= count:
|
||||
return
|
||||
time.sleep(0.2)
|
||||
raise SystemExit("балансировщик не видит %d реплик" % count)
|
||||
|
||||
|
||||
class Load:
|
||||
"""Несколько клиентов пишут в один чат, каждое событие сохраняется с отметкой времени."""
|
||||
|
||||
def __init__(self):
|
||||
self.user = new_user("chaos")
|
||||
self.chat = new_chat(self.user)
|
||||
self.stop = threading.Event()
|
||||
self.events = [] # (время, ok, реплика, статус)
|
||||
self.confirmed = {}
|
||||
self.lock = threading.Lock()
|
||||
self.threads = [threading.Thread(target=self.worker, args=(n,)) for n in range(WORKERS)]
|
||||
|
||||
def worker(self, number):
|
||||
index = 0
|
||||
while not self.stop.is_set():
|
||||
text = "worker-%d-%d-%s" % (number, index, uuid.uuid4().hex[:8])
|
||||
key = uuid.uuid4().hex
|
||||
index += 1
|
||||
while True:
|
||||
try:
|
||||
status, body, headers = send(self.user, self.chat, text, key=key, timeout=3)
|
||||
instance = headers.get("X-Instance-Id")
|
||||
except OSError:
|
||||
status, body, instance = 0, None, None
|
||||
now = time.monotonic()
|
||||
ok = status == 201
|
||||
with self.lock:
|
||||
self.events.append((now, ok, instance, status))
|
||||
if ok:
|
||||
self.confirmed[body["id"]] = body
|
||||
if ok or self.stop.is_set():
|
||||
break
|
||||
time.sleep(0.05) # неопределённый результат: тот же текст и тот же ключ
|
||||
|
||||
def start(self):
|
||||
for thread in self.threads:
|
||||
thread.start()
|
||||
|
||||
def finish(self):
|
||||
self.stop.set()
|
||||
for thread in self.threads:
|
||||
thread.join()
|
||||
|
||||
|
||||
def percentile(values, p):
|
||||
ordered = sorted(values)
|
||||
return round(ordered[max(0, math.ceil(p * len(ordered)) - 1)], 3) if ordered else None
|
||||
|
||||
|
||||
def summary(events, started, action_at, target=None):
|
||||
"""Показатели одного интервала: от action_at считается время до восстановления записи."""
|
||||
ok = [e for e in events if e[1]]
|
||||
failed = [e for e in events if not e[1]]
|
||||
elapsed = events[-1][0] - started
|
||||
gaps = [b[0] - a[0] for a, b in zip(ok, ok[1:])]
|
||||
after = [e for e in ok if e[0] >= action_at]
|
||||
last_on_target = [e[0] for e in ok if target and e[2] and target.startswith(e[2])]
|
||||
return {
|
||||
"seconds": round(elapsed, 2),
|
||||
"successful_requests": len(ok),
|
||||
"failed_attempts": len(failed),
|
||||
"failed_statuses": sorted({e[3] for e in failed}),
|
||||
"successful_rps": round(len(ok) / elapsed, 1),
|
||||
"longest_gap_between_successes_s": round(max(gaps), 3) if gaps else None,
|
||||
"first_success_after_action_s": round(after[0][0] - action_at, 3) if after else None,
|
||||
"last_success_on_target_after_action_s": round(last_on_target[-1] - action_at, 3)
|
||||
if last_on_target and last_on_target[-1] >= action_at else None,
|
||||
"instances_seen": len({e[2] for e in ok}),
|
||||
}
|
||||
|
||||
|
||||
def verify(load):
|
||||
items, _ = history(load.user, load.chat, 100)
|
||||
by_id = {item["id"]: item for item in items}
|
||||
texts = [item["text"] for item in items]
|
||||
lost = [mid for mid, message in load.confirmed.items() if by_id.get(mid) != message]
|
||||
result = {
|
||||
"confirmed": len(load.confirmed),
|
||||
"in_history": len(items),
|
||||
"lost_confirmed": len(lost),
|
||||
"duplicate_ids": len(items) - len(by_id),
|
||||
"duplicate_texts": len(texts) - len(set(texts)),
|
||||
}
|
||||
result["unconfirmed_but_saved"] = len(items) - len(load.confirmed)
|
||||
return result
|
||||
|
||||
|
||||
def replicas_up():
|
||||
"""Сколько реплик балансировщик считает рабочими, по его странице статистики."""
|
||||
csv = compose("exec", "-T", "lb", "wget", "-q", "-O", "-", "http://127.0.0.1:8404/stats;csv")
|
||||
return sum(line.startswith("api,api") and ",UP" in line for line in csv.splitlines())
|
||||
|
||||
|
||||
def seconds_until_excluded(replicas, since, limit=8):
|
||||
while time.monotonic() - since < limit:
|
||||
if replicas_up() < replicas:
|
||||
return round(time.monotonic() - since, 2)
|
||||
time.sleep(0.1)
|
||||
return None
|
||||
|
||||
|
||||
def replica_round(signal):
|
||||
containers = api_containers()
|
||||
wait_replicas(len(containers))
|
||||
rounds = []
|
||||
for container in containers:
|
||||
load = Load()
|
||||
started = time.monotonic()
|
||||
load.start()
|
||||
time.sleep(5)
|
||||
action_at = time.monotonic()
|
||||
command = {"SIGTERM": "stop", "SIGKILL": "kill", "HANG": "pause"}[signal]
|
||||
subprocess.run(["docker", command, container], check=True, stdout=subprocess.DEVNULL)
|
||||
stop_took = time.monotonic() - action_at
|
||||
excluded_after = seconds_until_excluded(len(containers), action_at)
|
||||
time.sleep(max(0, 10 - (time.monotonic() - action_at)))
|
||||
command = "unpause" if signal == "HANG" else "start"
|
||||
subprocess.run(["docker", command, container], check=True, stdout=subprocess.DEVNULL)
|
||||
wait_replicas(len(containers))
|
||||
time.sleep(2)
|
||||
load.finish()
|
||||
result = summary(load.events, started, action_at, container)
|
||||
result.update({"target": container[:12], "signal": signal, "stop_command_s": round(stop_took, 2),
|
||||
"excluded_by_lb_after_s": excluded_after})
|
||||
result["verify"] = verify(load)
|
||||
print(json.dumps(result, ensure_ascii=False))
|
||||
rounds.append(result)
|
||||
return rounds
|
||||
|
||||
|
||||
def images():
|
||||
inspect = ["docker", "inspect", "-f", "{{.Image}}"]
|
||||
return {c[:12]: subprocess.check_output(inspect + [c], text=True).strip()[:19] for c in api_containers()}
|
||||
|
||||
|
||||
def rolling_round():
|
||||
before = images()
|
||||
wait_replicas(len(before))
|
||||
load = Load()
|
||||
started = time.monotonic()
|
||||
load.start()
|
||||
time.sleep(5)
|
||||
action_at = time.monotonic()
|
||||
subprocess.run(["./scripts/rolling-update.sh"], cwd=ROOT, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
update_took = time.monotonic() - action_at
|
||||
time.sleep(5)
|
||||
load.finish()
|
||||
after = images()
|
||||
result = summary(load.events, started, action_at)
|
||||
result.update({"update_seconds": round(update_took, 2), "containers_before": before, "containers_after": after,
|
||||
"app_version": os.environ.get("APP_VERSION", "dev")})
|
||||
result["verify"] = verify(load)
|
||||
print(json.dumps(result, ensure_ascii=False))
|
||||
# без этой проверки скрипт, который ничего не заменил, выглядел бы как идеальное обновление
|
||||
if set(before) & set(after) or set(before.values()) & set(after.values()) or len(after) != len(before):
|
||||
raise SystemExit("FAIL: реплики не заменены новым образом")
|
||||
return [result]
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
parser.add_argument("mode", choices=["stop", "kill", "pause", "rolling"])
|
||||
parser.add_argument("--output")
|
||||
args = parser.parse_args()
|
||||
wait_ready()
|
||||
if args.mode == "rolling":
|
||||
rounds = rolling_round()
|
||||
else:
|
||||
rounds = replica_round({"stop": "SIGTERM", "kill": "SIGKILL", "pause": "HANG"}[args.mode])
|
||||
report = {
|
||||
"workload": "%d клиента, closed loop, POST сообщений через балансировщик, повтор с тем же ключом" % WORKERS,
|
||||
"mode": args.mode,
|
||||
"rounds": rounds,
|
||||
}
|
||||
if args.output:
|
||||
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
|
||||
bad = [r for r in rounds if r["verify"]["lost_confirmed"] or r["verify"]["duplicate_ids"] or r["verify"]["duplicate_texts"]]
|
||||
if bad:
|
||||
raise SystemExit("FAIL: потеряны или продублированы сообщения")
|
||||
print("PASS: подтверждённые сообщения на месте, дублей нет")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+11
@@ -0,0 +1,11 @@
|
||||
#!/bin/sh
|
||||
# Наполняет БД синтетической историей и печатает планы запросов пагинации.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
run_sql() {
|
||||
docker compose --env-file .env exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 -q
|
||||
}
|
||||
|
||||
run_sql < scripts/seed_history.sql
|
||||
run_sql < scripts/explain_history.sql
|
||||
@@ -0,0 +1,56 @@
|
||||
\set chat '00000000-0000-4000-8000-000000000100'
|
||||
\pset pager off
|
||||
|
||||
\echo '== Объём данных'
|
||||
SELECT count(*) AS messages_total,
|
||||
count(*) FILTER (WHERE chat_id = :'chat') AS messages_in_chat,
|
||||
pg_size_pretty(pg_relation_size('messages')) AS table_size,
|
||||
pg_size_pretty(pg_relation_size('messages_chat_history_idx')) AS index_size
|
||||
FROM messages;
|
||||
|
||||
\echo
|
||||
\echo '== 1. Первая страница (limit 50, запрос берёт 51 строку)'
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at,
|
||||
COALESCE((SELECT array_agg(a.attachment_id ORDER BY a.position) FROM message_attachments a
|
||||
WHERE a.message_id = messages.id), '{}'::uuid[]) AS attachment_ids
|
||||
FROM messages
|
||||
WHERE chat_id = :'chat'
|
||||
ORDER BY created_at, id LIMIT 51;
|
||||
|
||||
-- cursor на 5000-е сообщение чата, как его получил бы клиент после 100 страниц
|
||||
SELECT created_at AS after_time, id AS after_id FROM messages
|
||||
WHERE chat_id = :'chat' ORDER BY created_at, id OFFSET 4999 LIMIT 1 \gset
|
||||
|
||||
\echo
|
||||
\echo '== 2. Страница из середины истории: keyset после 5000-го сообщения'
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at,
|
||||
COALESCE((SELECT array_agg(a.attachment_id ORDER BY a.position) FROM message_attachments a
|
||||
WHERE a.message_id = messages.id), '{}'::uuid[]) AS attachment_ids
|
||||
FROM messages
|
||||
WHERE chat_id = :'chat' AND (created_at, id) > (:'after_time', :'after_id')
|
||||
ORDER BY created_at, id LIMIT 51;
|
||||
|
||||
\echo
|
||||
\echo '== 3. Та же страница через OFFSET (так делать не стали)'
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at,
|
||||
COALESCE((SELECT array_agg(a.attachment_id ORDER BY a.position) FROM message_attachments a
|
||||
WHERE a.message_id = messages.id), '{}'::uuid[]) AS attachment_ids
|
||||
FROM messages
|
||||
WHERE chat_id = :'chat'
|
||||
ORDER BY created_at, id OFFSET 5000 LIMIT 51;
|
||||
|
||||
\echo
|
||||
\echo '== 4. Запрос из пункта 2 без индекса messages_chat_history_idx (DROP INDEX внутри транзакции с ROLLBACK)'
|
||||
BEGIN;
|
||||
DROP INDEX messages_chat_history_idx;
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at,
|
||||
COALESCE((SELECT array_agg(a.attachment_id ORDER BY a.position) FROM message_attachments a
|
||||
WHERE a.message_id = messages.id), '{}'::uuid[]) AS attachment_ids
|
||||
FROM messages
|
||||
WHERE chat_id = :'chat' AND (created_at, id) > (:'after_time', :'after_id')
|
||||
ORDER BY created_at, id LIMIT 51;
|
||||
ROLLBACK;
|
||||
Executable
+32
@@ -0,0 +1,32 @@
|
||||
#!/bin/sh
|
||||
# Создаёт .env из .env.example и дописывает в него случайные пароли. Файл .env исключён из Git.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
[ -f .env ] || cp .env.example .env
|
||||
|
||||
if grep -q '^POSTGRES_PASSWORD=' .env; then
|
||||
# пароль PostgreSQL задаётся один раз при создании volume, новый пароль к старым данным не подойдёт
|
||||
echo ".env уже содержит пароли, ничего не меняю"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
postgres_password=$(openssl rand -hex 24)
|
||||
redis_password=$(openssl rand -hex 24)
|
||||
key() { openssl rand -hex "$1"; }
|
||||
cat >> .env <<END
|
||||
|
||||
# Локальные секреты, созданы scripts/init-env.sh. Compose кладёт их в контейнеры файлами /run/secrets/*.
|
||||
POSTGRES_PASSWORD=$postgres_password
|
||||
REDIS_PASSWORD=$redis_password
|
||||
DATABASE_URL=postgresql://messenger:$postgres_password@postgres:5432/messenger
|
||||
CACHE_URL=redis://:$redis_password@redis:6379/0
|
||||
S3_ADMIN_ACCESS_KEY_ID=$(key 12)
|
||||
S3_ADMIN_SECRET_ACCESS_KEY=$(key 24)
|
||||
S3_ACCESS_KEY_ID=$(key 12)
|
||||
S3_SECRET_ACCESS_KEY=$(key 24)
|
||||
S3_JANITOR_ACCESS_KEY_ID=$(key 12)
|
||||
S3_JANITOR_SECRET_ACCESS_KEY=$(key 24)
|
||||
END
|
||||
chmod 600 .env
|
||||
echo "пароли записаны в .env"
|
||||
Executable
+14
@@ -0,0 +1,14 @@
|
||||
#!/bin/sh
|
||||
# Перезапускает балансировщик, все реплики API, janitor и все хранилища. Volumes не трогает.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env restart postgres redis s3 api janitor lb
|
||||
|
||||
# /health/ready от S3 не зависит, поэтому готовность S3 ждём здесь: том данных появляется за 20-30 секунд
|
||||
container=$(docker compose --env-file .env ps -q s3)
|
||||
for attempt in $(seq 1 80); do
|
||||
[ "$(docker inspect -f '{{.State.Health.Status}}' "$container")" = healthy ] && exit 0
|
||||
sleep 1
|
||||
done
|
||||
echo "S3 не стал готов за 80 секунд" >&2
|
||||
exit 1
|
||||
Executable
+38
@@ -0,0 +1,38 @@
|
||||
#!/bin/sh
|
||||
# Поочерёдно заменяет реплики API новым образом: сначала новая готова, потом старая останавливается.
|
||||
# Миграции выполняются один раз до замены, поэтому они должны быть совместимы с работающей версией.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
compose="docker compose --env-file .env"
|
||||
|
||||
$compose build api
|
||||
$compose run --rm migrate
|
||||
|
||||
old=$($compose ps -q api)
|
||||
count=$(echo "$old" | wc -l | tr -d ' ')
|
||||
|
||||
wait_healthy() {
|
||||
for attempt in $(seq 1 60); do
|
||||
unhealthy=0
|
||||
# переменная цикла отдельная: в sh нет локальных переменных, а $container нужен внешнему циклу
|
||||
for replica in $($compose ps -q api); do
|
||||
[ "$(docker inspect -f '{{.State.Health.Status}}' "$replica")" = healthy ] || unhealthy=1
|
||||
done
|
||||
if [ "$unhealthy" = 0 ]; then
|
||||
return 0
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
echo "новая реплика не стала healthy за 60 секунд, замена остановлена" >&2
|
||||
exit 1
|
||||
}
|
||||
|
||||
for container in $old; do
|
||||
$compose up -d --no-deps --no-recreate --no-build --scale api=$((count + 1)) api
|
||||
wait_healthy
|
||||
# балансировщику нужно две удачные проверки с периодом 1 с, с запасом
|
||||
sleep 3
|
||||
docker stop "$container"
|
||||
docker rm "$container"
|
||||
done
|
||||
echo "замена завершена, реплик: $($compose ps -q api | wc -l | tr -d ' ')"
|
||||
@@ -0,0 +1,26 @@
|
||||
-- Синтетические данные для EXPLAIN: 21 чат и 60 000 сообщений, из них 10 000 в исследуемом чате.
|
||||
-- Повторный запуск ничего не добавляет. Войти под этим пользователем нельзя: вместо hash стоит заглушка.
|
||||
|
||||
INSERT INTO users (id, username, display_name, password_hash)
|
||||
VALUES ('00000000-0000-4000-8000-000000000001', 'explain_seed', 'Данные для EXPLAIN', '!')
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
INSERT INTO chats (id, title)
|
||||
SELECT ('00000000-0000-4000-8000-0000000001' || lpad(n::text, 2, '0'))::uuid, 'EXPLAIN чат ' || n
|
||||
FROM generate_series(0, 20) AS n
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
INSERT INTO chat_members (chat_id, user_id, position)
|
||||
SELECT id, '00000000-0000-4000-8000-000000000001', 0 FROM chats WHERE title LIKE 'EXPLAIN чат %'
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
-- чат 00: 10 000 сообщений; чаты 01..20: по 2 500. Время идёт с шагом в секунду и перемешано между чатами.
|
||||
INSERT INTO messages (chat_id, sender_id, text, created_at)
|
||||
SELECT ('00000000-0000-4000-8000-0000000001' || lpad((CASE WHEN n % 6 = 0 THEN 0 ELSE 1 + n % 20 END)::text, 2, '0'))::uuid,
|
||||
'00000000-0000-4000-8000-000000000001',
|
||||
'сообщение ' || n,
|
||||
now() - make_interval(secs => 60000 - n)
|
||||
FROM generate_series(1, 60000) AS n
|
||||
WHERE NOT EXISTS (SELECT 1 FROM messages WHERE chat_id = '00000000-0000-4000-8000-000000000100');
|
||||
|
||||
ANALYZE messages;
|
||||
@@ -0,0 +1,82 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Проверка SIGTERM через балансировщик: начатые запросы завершаются, новые уходят на другую реплику,
|
||||
процесс выходит быстрее 10 секунд. API наружу не опубликован, поэтому незаконченные запросы открываются
|
||||
на все реплики сразу: часть из них обязательно окажется на останавливаемой."""
|
||||
import json
|
||||
import socket
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import urllib.parse
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "student-tests"))
|
||||
from api import BASE_URL, call, new_chat, new_user
|
||||
|
||||
LIMIT_SECONDS = 10
|
||||
OPEN_REQUESTS = 6
|
||||
|
||||
|
||||
def main():
|
||||
containers = subprocess.run(
|
||||
["docker", "compose", "--env-file", ".env", "ps", "-q", "api"],
|
||||
cwd=ROOT, check=True, capture_output=True, text=True,
|
||||
).stdout.split()
|
||||
target = containers[0]
|
||||
address = urllib.parse.urlsplit(BASE_URL)
|
||||
user = new_user("sigterm")
|
||||
chat = new_chat(user)
|
||||
|
||||
# заголовки и половина тела: запрос уже начат, но ещё не закончен
|
||||
body = json.dumps({"text": "сообщение, отправленное во время остановки"}).encode()
|
||||
connections = []
|
||||
for _ in range(OPEN_REQUESTS):
|
||||
head = (
|
||||
"POST /api/v1/chats/%s/messages HTTP/1.1\r\nHost: %s\r\nContent-Type: application/json\r\n"
|
||||
"Content-Length: %d\r\nAuthorization: Bearer %s\r\nIdempotency-Key: %s\r\n\r\n"
|
||||
% (chat["id"], address.netloc, len(body), user["token"], uuid.uuid4().hex)
|
||||
).encode()
|
||||
connection = socket.create_connection((address.hostname, address.port), timeout=LIMIT_SECONDS)
|
||||
connection.sendall(head + body[:10])
|
||||
connections.append(connection)
|
||||
time.sleep(0.5)
|
||||
|
||||
print("$ docker kill --signal=SIGTERM", target[:12])
|
||||
started = time.monotonic()
|
||||
subprocess.run(["docker", "kill", "--signal=SIGTERM", target], check=True, stdout=subprocess.DEVNULL)
|
||||
time.sleep(1)
|
||||
|
||||
served = [call("GET", "/health/live")[2]["X-Instance-Id"] for _ in range(20)]
|
||||
new_on_target = sum(target.startswith(instance) for instance in served)
|
||||
print("новых запросов после SIGTERM: 20, попало на останавливаемую реплику:", new_on_target)
|
||||
|
||||
finished_on_target = 0
|
||||
statuses = []
|
||||
for connection in connections:
|
||||
connection.sendall(body[10:])
|
||||
answer = connection.recv(65536).decode("utf-8", "replace")
|
||||
connection.close()
|
||||
statuses.append(answer.split("\r\n")[0])
|
||||
for line in answer.split("\r\n"):
|
||||
if line.lower().startswith("x-instance-id:") and target.startswith(line.split(":")[1].strip()):
|
||||
finished_on_target += 1
|
||||
print("начатые до SIGTERM запросы:", sorted(set(statuses)))
|
||||
print("из них завершила останавливаемая реплика:", finished_on_target)
|
||||
|
||||
exit_code = subprocess.run(["docker", "wait", target], check=True, capture_output=True, text=True).stdout.strip()
|
||||
elapsed = time.monotonic() - started
|
||||
print("процесс завершился за %.2f с, код выхода %s" % (elapsed, exit_code))
|
||||
|
||||
# контейнер, остановленный через docker kill, сам не перезапускается: поднимаем его обратно
|
||||
subprocess.run(["docker", "start", target], check=True, stdout=subprocess.DEVNULL)
|
||||
|
||||
good = all(" 201 " in status for status in statuses)
|
||||
if not good or new_on_target or not finished_on_target or elapsed > LIMIT_SECONDS or exit_code != "0":
|
||||
raise SystemExit("FAIL")
|
||||
print("PASS: остановка корректная и укладывается в %d секунд" % LIMIT_SECONDS)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+14
@@ -0,0 +1,14 @@
|
||||
#!/bin/sh
|
||||
# Останавливает реплику API, которая обслужила тест, и оставляет её остановленной.
|
||||
# Вернуть реплику: make restore
|
||||
set -eu
|
||||
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
# X-Instance-Id равен короткому id контейнера; ищем только среди контейнеров сервиса api этого стенда
|
||||
container=$(docker compose --env-file .env ps -q api | grep "^$TARGET_INSTANCE_ID" || true)
|
||||
if [ -z "$container" ]; then
|
||||
echo "реплика $TARGET_INSTANCE_ID не найдена среди контейнеров сервиса api" >&2
|
||||
exit 3
|
||||
fi
|
||||
docker stop "$container"
|
||||
Executable
+120
@@ -0,0 +1,120 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Пик памяти реплик API при одновременных загрузках файлов около 10 MiB и самых тяжёлых JPEG.
|
||||
|
||||
Перед замером реплики перезапускаются, чтобы обнулить VmHWM (пик памяти процесса). Уровни идут по
|
||||
возрастанию, поэтому VmHWM после каждого уровня показывает пик этого уровня. memory.peak контейнера
|
||||
больше: в него входит кэш страниц временных файлов, который система может освободить.
|
||||
|
||||
Последний уровень — прогрессивный CMYK JPEG на 40 млн пикселей: декодер держит коэффициенты всего
|
||||
изображения, это худший случай для памяти. Загрузки идут параллельно, декодирование по одному на реплику.
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import urllib.parse
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "student-tests"))
|
||||
from api import call, new_chat, new_user
|
||||
from samples import noisy_png
|
||||
|
||||
LEVELS = (1, 10, 30)
|
||||
HEAVY_UPLOADS = 10
|
||||
MAKE_HEAVY_JPEG = """
|
||||
import sys
|
||||
from PIL import Image
|
||||
image = Image.effect_noise((7300 // 16, 5470 // 16), 40).resize((7300, 5470)).convert("CMYK")
|
||||
image.save(sys.stdout.buffer, "JPEG", quality=50, progressive=True)
|
||||
"""
|
||||
|
||||
|
||||
def compose(*args):
|
||||
command = ["docker", "compose", "--env-file", ".env", *args]
|
||||
return subprocess.run(command, cwd=ROOT, check=True, capture_output=True, text=True).stdout
|
||||
|
||||
|
||||
def memory():
|
||||
result = {}
|
||||
for container in compose("ps", "-q", "api").split():
|
||||
status = subprocess.check_output(["docker", "exec", container, "cat", "/proc/1/status"], text=True)
|
||||
fields = dict(line.split(":", 1) for line in status.splitlines() if ":" in line)
|
||||
peak = subprocess.check_output(["docker", "exec", container, "cat", "/sys/fs/cgroup/memory.peak"], text=True)
|
||||
result[container[:12]] = {
|
||||
"process_peak_rss_mib": round(int(fields["VmHWM"].split()[0]) / 1024, 1),
|
||||
"cgroup_peak_mib": round(int(peak) / 1024 / 1024, 1),
|
||||
}
|
||||
return result
|
||||
|
||||
|
||||
def wait_ready():
|
||||
deadline = time.monotonic() + 60
|
||||
seen = set()
|
||||
while time.monotonic() < deadline and len(seen) < 2:
|
||||
try:
|
||||
status, _, headers = call("GET", "/health/ready", timeout=2)
|
||||
if status == 200:
|
||||
seen.add(headers["X-Instance-Id"])
|
||||
except OSError:
|
||||
pass
|
||||
time.sleep(0.2)
|
||||
|
||||
|
||||
def heavy_jpeg():
|
||||
# в отдельном контейнере: создание такого файла требует много памяти, реплику это не должно затрагивать
|
||||
command = ["docker", "run", "--rm", "-i", "--memory=2g", "--entrypoint", "python", "mtusi-messenger:lab4", "-"]
|
||||
return subprocess.run(command, input=MAKE_HEAVY_JPEG.encode(), check=True, capture_output=True).stdout
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
parser.add_argument("--output")
|
||||
args = parser.parse_args()
|
||||
data = noisy_png(10 * 1024 * 1024 - 4096)
|
||||
compose("restart", "api")
|
||||
wait_ready()
|
||||
user = new_user("peak")
|
||||
chat = new_chat(user)
|
||||
path = "/api/v1/chats/%s/attachments?filename=peak.png" % urllib.parse.quote(chat["id"])
|
||||
levels = [{"parallel_uploads": 0, "memory": memory()}]
|
||||
|
||||
def run_level(level, content, content_type, label):
|
||||
started = time.monotonic()
|
||||
|
||||
def post(_):
|
||||
sent = time.monotonic()
|
||||
headers = {"Content-Type": content_type}
|
||||
status = call("POST", path, raw=content, user=user, headers=headers, timeout=60)[0]
|
||||
return status, time.monotonic() - sent
|
||||
|
||||
with ThreadPoolExecutor(max_workers=level) as pool:
|
||||
results = list(pool.map(post, range(level)))
|
||||
statuses = [status for status, _ in results]
|
||||
entry = {
|
||||
"file": label,
|
||||
"parallel_uploads": level,
|
||||
"file_bytes": len(content),
|
||||
"seconds": round(time.monotonic() - started, 2),
|
||||
"slowest_upload_s": round(max(took for _, took in results), 2),
|
||||
"statuses": {str(s): statuses.count(s) for s in sorted(set(statuses))},
|
||||
"memory": memory(),
|
||||
}
|
||||
print(json.dumps(entry, ensure_ascii=False))
|
||||
levels.append(entry)
|
||||
|
||||
for level in LEVELS:
|
||||
run_level(level, data, "image/png", "PNG 10 MiB")
|
||||
run_level(HEAVY_UPLOADS, heavy_jpeg(), "image/jpeg", "прогрессивный CMYK JPEG, 40 млн пикселей")
|
||||
report = {"limit_per_replica_mib": 512, "replicas": 2, "levels": levels}
|
||||
if args.output:
|
||||
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
|
||||
if any(set(level.get("statuses", {"201": 1})) != {"201"} for level in levels):
|
||||
raise SystemExit("FAIL: не все загрузки успешны")
|
||||
print("PASS: все загрузки успешны")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+12
@@ -0,0 +1,12 @@
|
||||
#!/bin/sh
|
||||
# Ждёт, пока /health/ready ответит 200, не дольше 60 секунд.
|
||||
BASE_URL=${BASE_URL:-http://localhost:8080}
|
||||
for attempt in $(seq 1 60); do
|
||||
if curl -fs -o /dev/null "$BASE_URL/health/ready"; then
|
||||
echo "готов: $BASE_URL"
|
||||
exit 0
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
echo "стенд не стал готов за 60 секунд: $BASE_URL" >&2
|
||||
exit 1
|
||||
@@ -0,0 +1,68 @@
|
||||
import os
|
||||
import socket
|
||||
from pathlib import Path
|
||||
|
||||
HOST = os.getenv("APP_HOST", "0.0.0.0")
|
||||
PORT = int(os.getenv("APP_PORT", "8080"))
|
||||
ENV = os.getenv("APP_ENV", "lab")
|
||||
VERSION = os.getenv("APP_VERSION", "dev")
|
||||
# имя контейнера совпадает с коротким id, по нему scripts/stop-one.sh находит реплику; в lab7 заменить на alias
|
||||
INSTANCE_ID = socket.gethostname()
|
||||
LOG_LEVEL = os.getenv("LOG_LEVEL", "info").lower()
|
||||
# docker stop по умолчанию ждёт 10 секунд, поэтому укладываемся с запасом
|
||||
SHUTDOWN_TIMEOUT = int(os.getenv("SHUTDOWN_TIMEOUT", "8"))
|
||||
|
||||
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
|
||||
SESSION_STORE = os.getenv("SESSION_STORE", "redis")
|
||||
# сколько хранить результат отправки сообщения по Idempotency-Key, контракт требует не менее 24 часов
|
||||
IDEMPOTENCY_TTL_SECONDS = int(os.getenv("IDEMPOTENCY_TTL_SECONDS", "86400"))
|
||||
|
||||
# пул соединений с PostgreSQL и таймауты, всё в секундах
|
||||
DB_POOL_MIN_SIZE = int(os.getenv("DB_POOL_MIN_SIZE", "2"))
|
||||
DB_POOL_MAX_SIZE = int(os.getenv("DB_POOL_MAX_SIZE", "10"))
|
||||
DB_POOL_TIMEOUT = float(os.getenv("DB_POOL_TIMEOUT", "3"))
|
||||
DB_CONNECT_TIMEOUT = int(os.getenv("DB_CONNECT_TIMEOUT", "3"))
|
||||
DB_STATEMENT_TIMEOUT = int(os.getenv("DB_STATEMENT_TIMEOUT", "5"))
|
||||
|
||||
# вложения: лимиты контракта и время на приём одного файла
|
||||
MAX_UPLOAD_BYTES = int(os.getenv("MAX_UPLOAD_BYTES", "10485760"))
|
||||
MAX_IMAGE_PIXELS = int(os.getenv("MAX_IMAGE_PIXELS", "40000000"))
|
||||
MAX_JSON_BYTES = int(os.getenv("MAX_JSON_BYTES", "1048576"))
|
||||
MAX_PARALLEL_UPLOADS = int(os.getenv("MAX_PARALLEL_UPLOADS", "32"))
|
||||
UPLOAD_TIMEOUT_SECONDS = int(os.getenv("UPLOAD_TIMEOUT_SECONDS", "60"))
|
||||
# записей в S3 одновременно с одной реплики и сколько загрузка ждёт своей очереди
|
||||
S3_PARALLEL_WRITES = int(os.getenv("S3_PARALLEL_WRITES", "4"))
|
||||
S3_WRITE_QUEUE_SECONDS = int(os.getenv("S3_WRITE_QUEUE_SECONDS", "10"))
|
||||
|
||||
S3_ENDPOINT = os.getenv("S3_ENDPOINT", "http://s3:9000")
|
||||
S3_REGION = os.getenv("S3_REGION", "us-east-1")
|
||||
S3_BUCKET = os.getenv("S3_BUCKET", "messenger-attachments")
|
||||
S3_CONNECT_TIMEOUT = float(os.getenv("S3_CONNECT_TIMEOUT", "2"))
|
||||
S3_READ_TIMEOUT = float(os.getenv("S3_READ_TIMEOUT", "5"))
|
||||
S3_POOL_SIZE = int(os.getenv("S3_POOL_SIZE", "32"))
|
||||
|
||||
# janitor: возраст, после которого незавершённая загрузка считается брошенной, и период проходов
|
||||
ATTACHMENT_GRACE_SECONDS = int(os.getenv("ATTACHMENT_GRACE_SECONDS", "3600"))
|
||||
JANITOR_INTERVAL_SECONDS = int(os.getenv("JANITOR_INTERVAL_SECONDS", "300"))
|
||||
|
||||
CACHE_POOL_MAX_SIZE = int(os.getenv("CACHE_POOL_MAX_SIZE", "20"))
|
||||
CACHE_TIMEOUT = float(os.getenv("CACHE_TIMEOUT", "2"))
|
||||
|
||||
|
||||
def read_secret(name: str) -> str:
|
||||
"""Значение берётся из файла, путь к которому лежит в NAME_FILE. Для отладки без Docker подойдёт и сама NAME."""
|
||||
path = os.getenv(name + "_FILE")
|
||||
if path and Path(path).is_file():
|
||||
return Path(path).read_text().strip()
|
||||
value = os.getenv(name)
|
||||
if not value:
|
||||
raise SystemExit(f"не задан {name}_FILE или {name}")
|
||||
return value
|
||||
|
||||
|
||||
def database_url() -> str:
|
||||
return read_secret("DATABASE_URL")
|
||||
|
||||
|
||||
def cache_url() -> str:
|
||||
return read_secret("CACHE_URL")
|
||||
@@ -0,0 +1,38 @@
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
|
||||
class ApiError(Exception):
|
||||
def __init__(self, status: int, code: str, message: str, headers=None):
|
||||
self.status = status
|
||||
self.code = code
|
||||
self.message = message
|
||||
self.headers = headers
|
||||
|
||||
|
||||
def invalid(message: str) -> ApiError:
|
||||
return ApiError(400, "invalid_request", message)
|
||||
|
||||
|
||||
def bad_credentials() -> ApiError:
|
||||
# один и тот же ответ для неизвестного username и неверного пароля
|
||||
return ApiError(
|
||||
401, "unauthorized", "Неверное имя пользователя или пароль",
|
||||
{"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
|
||||
)
|
||||
|
||||
|
||||
def unauthorized() -> ApiError:
|
||||
return ApiError(
|
||||
401, "unauthorized", "Нужен действующий Bearer-токен",
|
||||
{"WWW-Authenticate": 'Bearer realm="messenger"'},
|
||||
)
|
||||
|
||||
|
||||
def not_found() -> ApiError:
|
||||
# одинаковый ответ для несуществующего и чужого объекта
|
||||
return ApiError(404, "not_found", "Объект не найден")
|
||||
|
||||
|
||||
def error_response(request_id: str, status: int, code: str, message: str, headers=None) -> JSONResponse:
|
||||
body = {"error": {"code": code, "message": message, "request_id": request_id}}
|
||||
return JSONResponse(body, status_code=status, headers=headers)
|
||||
@@ -0,0 +1,11 @@
|
||||
"""Проверка для Docker HEALTHCHECK: код 0, если /health/ready отвечает 200."""
|
||||
import os
|
||||
import sys
|
||||
import urllib.request
|
||||
|
||||
port = os.getenv("APP_PORT", "8080")
|
||||
try:
|
||||
with urllib.request.urlopen(f"http://127.0.0.1:{port}/health/ready", timeout=4) as response:
|
||||
sys.exit(0 if response.status == 200 else 1)
|
||||
except Exception:
|
||||
sys.exit(1)
|
||||
+281
@@ -0,0 +1,281 @@
|
||||
"""Проверка PNG и JPEG по содержимому, память ограничена.
|
||||
|
||||
Размер изображения берётся из заголовка до любой работы с данными, поэтому decompression bomb
|
||||
отсекается сразу.
|
||||
|
||||
PNG проверяется потоково без декодера: CRC блоков, порядок блоков, распаковка с выбрасыванием
|
||||
результата, байт фильтра в начале каждой строки, точный объём данных. Память не зависит от размера
|
||||
изображения, поэтому Pillow здесь не нужен.
|
||||
|
||||
JPEG так проверить нельзя: чтобы понять, что в скане настоящие данные, их надо декодировать. Поэтому
|
||||
сначала идёт быстрый разбор маркеров, а потом настоящий декодер с уменьшением в 8 раз. Обычный JPEG
|
||||
при этом занимает несколько МБ. Прогрессивный хранит коэффициенты всего изображения, это до 2 байт на
|
||||
отсчёт, то есть до 320 МБ на 40 млн пикселей CMYK, поэтому декодирование идёт по одному на реплику.
|
||||
"""
|
||||
import struct
|
||||
import threading
|
||||
import zlib
|
||||
|
||||
BLOCK = 64 * 1024
|
||||
PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
|
||||
JPEG_SIGNATURE = b"\xff\xd8\xff"
|
||||
# допустимая глубина цвета для каждого типа PNG и число каналов
|
||||
PNG_COLOR_TYPES = {0: ((1, 2, 4, 8, 16), 1), 2: ((8, 16), 3), 3: ((1, 2, 4, 8), 1), 4: ((8, 16), 2), 6: ((8, 16), 4)}
|
||||
# все маркеры SOF, кроме DHT (C4), JPG (C8) и DAC (CC), которые попадают в тот же диапазон
|
||||
JPEG_SOF = set(range(0xC0, 0xD0)) - {0xC4, 0xC8, 0xCC}
|
||||
# кодирование Хаффмана: минимум 1 бит на блок. У арифметического (C9-CF) нижней границы нет
|
||||
JPEG_HUFFMAN_SOF = {0xC0, 0xC1, 0xC2}
|
||||
# каждый скан заставляет декодер пройти всё изображение, а в 10 MiB их можно уместить тысячи;
|
||||
# настоящим файлам хватает нескольких десятков
|
||||
MAX_JPEG_SCANS = 100
|
||||
PNG_CRITICAL_CHUNKS = {b"IHDR", b"PLTE", b"IDAT", b"IEND"}
|
||||
# проходы Adam7: первая колонка, первая строка, шаг по колонкам, шаг по строкам
|
||||
ADAM7_PASSES = ((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))
|
||||
|
||||
# см. начало файла: не больше одного тяжёлого декодирования на реплику
|
||||
decode_lock = threading.Lock()
|
||||
|
||||
|
||||
class NotAnImage(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class TooManyPixels(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def inspect(file, max_pixels: int) -> str:
|
||||
"""Возвращает настоящий тип файла или бросает NotAnImage / TooManyPixels."""
|
||||
file.seek(0)
|
||||
head = file.read(8)
|
||||
try:
|
||||
if head == PNG_SIGNATURE:
|
||||
check_png(file, max_pixels)
|
||||
return "image/png"
|
||||
if head[:3] == JPEG_SIGNATURE:
|
||||
file.seek(2)
|
||||
check_jpeg_structure(file, max_pixels)
|
||||
decode_jpeg(file)
|
||||
return "image/jpeg"
|
||||
except (struct.error, zlib.error, ValueError) as error:
|
||||
raise NotAnImage() from error
|
||||
raise NotAnImage()
|
||||
|
||||
|
||||
def check_size(width: int, height: int, max_pixels: int) -> None:
|
||||
if width == 0 or height == 0:
|
||||
raise NotAnImage()
|
||||
if width * height > max_pixels:
|
||||
raise TooManyPixels()
|
||||
|
||||
|
||||
def png_passes(width: int, height: int, bits_per_pixel: int, interlaced: bool) -> list:
|
||||
"""Группы строк распакованных данных: (длина строки вместе с байтом фильтра, число строк)."""
|
||||
if not interlaced:
|
||||
return [(1 + (width * bits_per_pixel + 7) // 8, height)]
|
||||
passes = []
|
||||
for column, row, column_step, row_step in ADAM7_PASSES:
|
||||
columns = (width - column + column_step - 1) // column_step
|
||||
rows = (height - row + row_step - 1) // row_step
|
||||
if columns > 0 and rows > 0: # у маленького изображения часть проходов пуста
|
||||
passes.append((1 + (columns * bits_per_pixel + 7) // 8, rows))
|
||||
return passes
|
||||
|
||||
|
||||
class ScanlineFilters:
|
||||
"""Следит за байтами фильтра в распакованном потоке, сами данные не хранит."""
|
||||
|
||||
def __init__(self, passes: list):
|
||||
self.passes = iter(passes)
|
||||
self.position = 0 # смещение начала следующего блока в распакованном потоке
|
||||
self.next_filter = 0 # смещение следующего байта фильтра
|
||||
self.row_size, self.rows_left = next(self.passes, (0, 0))
|
||||
self.expected = sum(size * rows for size, rows in passes)
|
||||
|
||||
def feed(self, block: bytes) -> None:
|
||||
end = self.position + len(block)
|
||||
if end > self.expected:
|
||||
raise NotAnImage()
|
||||
while self.rows_left and self.next_filter < end:
|
||||
start = self.next_filter - self.position
|
||||
rows = min(self.rows_left, (len(block) - start + self.row_size - 1) // self.row_size)
|
||||
# срез вместо цикла: строк может быть 40 млн, а Python проходит их слишком долго
|
||||
if max(block[start:start + rows * self.row_size:self.row_size]) > 4:
|
||||
raise NotAnImage()
|
||||
self.next_filter += rows * self.row_size
|
||||
self.rows_left -= rows
|
||||
if not self.rows_left:
|
||||
self.row_size, self.rows_left = next(self.passes, (0, 0))
|
||||
self.position = end
|
||||
|
||||
|
||||
def check_png(file, max_pixels: int) -> None:
|
||||
inflater = zlib.decompressobj()
|
||||
filters = None
|
||||
seen_palette = False
|
||||
seen_data = False
|
||||
data_finished = False
|
||||
color = None
|
||||
while True:
|
||||
length, kind = struct.unpack(">I4s", read_exact(file, 8))
|
||||
if length >= 2**31 or not kind.isalpha() or (filters is None and kind != b"IHDR"):
|
||||
raise NotAnImage()
|
||||
# заглавная первая буква значит «без понимания этого блока файл читать нельзя»
|
||||
if kind[0] < 0x61 and kind not in PNG_CRITICAL_CHUNKS:
|
||||
raise NotAnImage()
|
||||
if kind == b"IDAT":
|
||||
if data_finished or (color == 3 and not seen_palette):
|
||||
raise NotAnImage()
|
||||
elif seen_data:
|
||||
data_finished = True # блоки IDAT должны идти подряд
|
||||
crc = zlib.crc32(kind)
|
||||
remaining = length
|
||||
body = b""
|
||||
while remaining:
|
||||
block = file.read(min(BLOCK, remaining))
|
||||
if not block:
|
||||
raise NotAnImage()
|
||||
remaining -= len(block)
|
||||
crc = zlib.crc32(block, crc)
|
||||
if kind == b"IHDR" and len(body) <= 13:
|
||||
body += block
|
||||
elif kind == b"IDAT":
|
||||
seen_data = True
|
||||
inflate(inflater, block, filters)
|
||||
if struct.unpack(">I", read_exact(file, 4))[0] != crc:
|
||||
raise NotAnImage()
|
||||
if kind == b"IHDR":
|
||||
if filters is not None or length != 13:
|
||||
raise NotAnImage()
|
||||
width, height, depth, color, compression, filtering, interlace = struct.unpack(">IIBBBBB", body)
|
||||
depths, channels = PNG_COLOR_TYPES.get(color, ((), 0))
|
||||
if depth not in depths or compression != 0 or filtering != 0 or interlace not in (0, 1):
|
||||
raise NotAnImage()
|
||||
check_size(width, height, max_pixels)
|
||||
filters = ScanlineFilters(png_passes(width, height, depth * channels, interlace == 1))
|
||||
elif kind == b"PLTE":
|
||||
if seen_palette or seen_data or color in (0, 4) or length == 0 or length % 3 or length > 768:
|
||||
raise NotAnImage()
|
||||
seen_palette = True
|
||||
elif kind == b"IEND":
|
||||
if length != 0:
|
||||
raise NotAnImage()
|
||||
break
|
||||
if not seen_data or not inflater.eof or inflater.unused_data or file.read(1):
|
||||
raise NotAnImage()
|
||||
if filters.position != filters.expected:
|
||||
raise NotAnImage()
|
||||
|
||||
|
||||
def inflate(inflater, block: bytes, filters: ScanlineFilters) -> None:
|
||||
"""Распаковывает блок и проверяет строки, не накапливая результат."""
|
||||
while block and not inflater.eof:
|
||||
filters.feed(inflater.decompress(block, BLOCK))
|
||||
block = inflater.unconsumed_tail
|
||||
|
||||
|
||||
def check_jpeg_structure(file, max_pixels: int) -> None:
|
||||
"""Быстрая проверка маркеров: размер, число сканов, объём данных. Содержимое проверит декодер."""
|
||||
file.seek(0, 2)
|
||||
end = file.tell()
|
||||
file.seek(2)
|
||||
frame = None
|
||||
scans = 0
|
||||
scan_bytes = 0
|
||||
while True:
|
||||
if read_exact(file, 1) != b"\xff":
|
||||
raise NotAnImage()
|
||||
marker = 0xFF
|
||||
while marker == 0xFF: # перед маркером разрешены байты-заполнители
|
||||
marker = read_exact(file, 1)[0]
|
||||
if marker == 0xD9: # конец изображения; данные после него допустимы, так делают камеры
|
||||
break
|
||||
if 0xD0 <= marker <= 0xD7 or marker == 0x01:
|
||||
continue
|
||||
if marker == 0x00 or marker == 0xD8:
|
||||
raise NotAnImage()
|
||||
length = struct.unpack(">H", read_exact(file, 2))[0]
|
||||
if length < 2 or file.tell() + length - 2 > end:
|
||||
raise NotAnImage()
|
||||
segment = read_exact(file, length - 2)
|
||||
if marker in JPEG_SOF:
|
||||
if frame is not None:
|
||||
raise NotAnImage()
|
||||
frame = marker, parse_frame(segment, max_pixels)
|
||||
if marker == 0xDA:
|
||||
scans += 1
|
||||
if frame is None or scans > MAX_JPEG_SCANS:
|
||||
raise NotAnImage()
|
||||
scan_bytes += skip_scan(file)
|
||||
if frame is None or not scans:
|
||||
raise NotAnImage()
|
||||
# без этой проверки декодер принял бы заголовки с почти пустым сканом: конец данных он считает предупреждением
|
||||
if frame[0] in JPEG_HUFFMAN_SOF and scan_bytes * 8 < frame[1]:
|
||||
raise NotAnImage()
|
||||
|
||||
|
||||
def parse_frame(segment: bytes, max_pixels: int) -> int:
|
||||
"""Проверяет заголовок кадра и возвращает число блоков изображения."""
|
||||
if len(segment) < 6:
|
||||
raise NotAnImage()
|
||||
_, height, width, components = struct.unpack(">BHHB", segment[:6])
|
||||
if components not in (1, 3, 4) or len(segment) != 6 + 3 * components:
|
||||
raise NotAnImage()
|
||||
check_size(width, height, max_pixels)
|
||||
sampling = [segment[7 + 3 * index] for index in range(components)]
|
||||
horizontal = [value >> 4 for value in sampling]
|
||||
vertical = [value & 0x0F for value in sampling]
|
||||
if not all(1 <= value <= 4 for value in horizontal + vertical):
|
||||
raise NotAnImage()
|
||||
mcu_columns = (width + 8 * max(horizontal) - 1) // (8 * max(horizontal))
|
||||
mcu_rows = (height + 8 * max(vertical) - 1) // (8 * max(vertical))
|
||||
return mcu_columns * mcu_rows * sum(h * v for h, v in zip(horizontal, vertical))
|
||||
|
||||
|
||||
def skip_scan(file) -> int:
|
||||
"""Проходит сжатые данные скана, оставляет файл на следующем маркере и возвращает их объём."""
|
||||
begin = file.tell()
|
||||
while True:
|
||||
start = file.tell()
|
||||
block = file.read(BLOCK)
|
||||
if len(block) < 2:
|
||||
raise NotAnImage()
|
||||
position = 0
|
||||
while True:
|
||||
position = block.find(b"\xff", position)
|
||||
if position < 0:
|
||||
break
|
||||
if position + 1 == len(block): # маркер разрезан границей блока
|
||||
file.seek(start + position)
|
||||
break
|
||||
following = block[position + 1]
|
||||
if following == 0x00 or 0xD0 <= following <= 0xD7:
|
||||
position += 2
|
||||
elif following == 0xFF:
|
||||
position += 1
|
||||
else:
|
||||
file.seek(start + position)
|
||||
return start + position - begin
|
||||
|
||||
|
||||
def decode_jpeg(file) -> None:
|
||||
"""Настоящее декодирование с уменьшением: файл принимается, только если декодер дошёл до конца."""
|
||||
from PIL import Image # здесь, а не в начале файла: разбор PNG декодера не требует
|
||||
|
||||
file.seek(0)
|
||||
with decode_lock:
|
||||
try:
|
||||
with Image.open(file, formats=["JPEG"]) as image:
|
||||
image.draft(None, (max(1, image.width // 8), max(1, image.height // 8)))
|
||||
image.load()
|
||||
except MemoryError:
|
||||
raise
|
||||
except Exception as error: # у декодера нет единого исключения: OSError, SyntaxError, ValueError и другие
|
||||
raise NotAnImage() from error
|
||||
|
||||
|
||||
def read_exact(file, size: int) -> bytes:
|
||||
data = file.read(size)
|
||||
if len(data) != size:
|
||||
raise NotAnImage()
|
||||
return data
|
||||
@@ -0,0 +1,93 @@
|
||||
"""Убирает следы незавершённых загрузок. Работает отдельным сервисом со своим S3-ключом.
|
||||
|
||||
1. Строка pending старше grace period: загрузка оборвалась между записью в БД, S3 и подтверждением.
|
||||
Сначала удаляется объект, потом строка: при сбое посередине следующий проход повторит то же самое.
|
||||
2. Объект старше grace period без строки в БД: сверка на случай, если строка потеряна.
|
||||
|
||||
Строка появляется раньше объекта, поэтому у идущей загрузки строка есть всегда, а grace period
|
||||
больше максимального времени загрузки.
|
||||
"""
|
||||
import argparse
|
||||
import logging
|
||||
import signal
|
||||
import sys
|
||||
import threading
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
import psycopg
|
||||
from botocore.exceptions import BotoCoreError, ClientError
|
||||
|
||||
import config
|
||||
from objects import ObjectStore
|
||||
|
||||
logging.basicConfig(level=config.LOG_LEVEL.upper(), format="%(asctime)s %(levelname)s %(name)s: %(message)s", stream=sys.stdout)
|
||||
logging.getLogger("botocore").setLevel(logging.WARNING)
|
||||
log = logging.getLogger("janitor")
|
||||
|
||||
|
||||
def clean_pending(conn, objects, grace: int, dry_run: bool) -> int:
|
||||
rows = conn.execute(
|
||||
"SELECT id, object_key FROM attachments WHERE state = 'pending' "
|
||||
"AND created_at < now() - make_interval(secs => %s)",
|
||||
(grace,),
|
||||
).fetchall()
|
||||
for attachment_id, key in rows:
|
||||
if dry_run:
|
||||
continue
|
||||
objects.delete(key)
|
||||
conn.execute("DELETE FROM attachments WHERE id = %s AND state = 'pending'", (attachment_id,))
|
||||
return len(rows)
|
||||
|
||||
|
||||
def clean_orphans(conn, objects, grace: int, dry_run: bool) -> int:
|
||||
removed = 0
|
||||
border = datetime.now(timezone.utc) - timedelta(seconds=grace)
|
||||
for page in objects.pages():
|
||||
old = [item["Key"] for item in page if item["LastModified"] < border]
|
||||
if not old:
|
||||
continue
|
||||
known = {row[0] for row in conn.execute("SELECT object_key FROM attachments WHERE object_key = ANY(%s)", (old,))}
|
||||
for key in old:
|
||||
if key not in known:
|
||||
removed += 1
|
||||
if not dry_run:
|
||||
objects.delete(key)
|
||||
return removed
|
||||
|
||||
|
||||
def run_once(objects, grace: int, dry_run: bool = False) -> None:
|
||||
with psycopg.connect(config.database_url(), autocommit=True, connect_timeout=config.DB_CONNECT_TIMEOUT) as conn:
|
||||
pending = clean_pending(conn, objects, grace, dry_run)
|
||||
orphans = clean_orphans(conn, objects, grace, dry_run)
|
||||
log.info("pass finished dry_run=%s pending_removed=%d orphans_removed=%d grace=%ds", dry_run, pending, orphans, grace)
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
parser.add_argument("--once", action="store_true", help="один проход и выход")
|
||||
parser.add_argument("--dry-run", action="store_true", help="только посчитать, ничего не удалять")
|
||||
parser.add_argument("--grace-seconds", type=int, default=config.ATTACHMENT_GRACE_SECONDS)
|
||||
args = parser.parse_args()
|
||||
objects = ObjectStore(config.read_secret("S3_JANITOR_ACCESS_KEY_ID"), config.read_secret("S3_JANITOR_SECRET_ACCESS_KEY"))
|
||||
if args.once:
|
||||
try:
|
||||
run_once(objects, args.grace_seconds, args.dry_run)
|
||||
except (psycopg.Error, BotoCoreError, ClientError) as error:
|
||||
sys.exit(f"проход не выполнен: {type(error).__name__}")
|
||||
return
|
||||
# PID 1 без обработчика не завершается по SIGTERM
|
||||
stop = threading.Event()
|
||||
signal.signal(signal.SIGTERM, lambda *_: stop.set())
|
||||
log.info("started interval=%ds grace=%ds", config.JANITOR_INTERVAL_SECONDS, args.grace_seconds)
|
||||
while not stop.is_set():
|
||||
try:
|
||||
run_once(objects, args.grace_seconds)
|
||||
except (psycopg.Error, BotoCoreError, ClientError) as error:
|
||||
# хранилище недоступно: следующий проход повторит работу
|
||||
log.warning("pass failed: %s", type(error).__name__)
|
||||
stop.wait(config.JANITOR_INTERVAL_SECONDS)
|
||||
log.info("stopped")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+496
@@ -0,0 +1,496 @@
|
||||
import asyncio
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import unicodedata
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import Annotated
|
||||
from urllib.parse import quote
|
||||
from uuid import UUID
|
||||
|
||||
import psycopg
|
||||
import redis
|
||||
import uvicorn
|
||||
from botocore.exceptions import BotoCoreError, ClientError
|
||||
from fastapi import Depends, FastAPI, Path, Query, Request, Response
|
||||
from fastapi.concurrency import run_in_threadpool
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import StreamingResponse
|
||||
from pydantic import ValidationError
|
||||
from starlette.exceptions import HTTPException
|
||||
from starlette.requests import ClientDisconnect
|
||||
|
||||
import config
|
||||
import images
|
||||
import security
|
||||
from errors import ApiError, bad_credentials, error_response, invalid, not_found, unauthorized
|
||||
from objects import ObjectStore
|
||||
from schemas import UUID_PATTERN, CreateChat, CreateMessage, CreateUser
|
||||
from sessions import Sessions
|
||||
from store import TIME_FORMAT, IdempotencyConflict, Store, UnknownAttachment, UnknownMember, UsernameTaken, timestamp
|
||||
|
||||
logging.basicConfig(
|
||||
level=config.LOG_LEVEL.upper(),
|
||||
format="%(asctime)s %(levelname)s %(name)s: %(message)s",
|
||||
stream=sys.stdout,
|
||||
)
|
||||
log = logging.getLogger("messenger")
|
||||
|
||||
if config.SESSION_STORE != "redis":
|
||||
sys.exit("поддерживается только SESSION_STORE=redis")
|
||||
|
||||
USERNAME = re.compile(r"[a-z0-9_]{3,32}")
|
||||
IDEMPOTENCY_KEY = re.compile(r"[A-Za-z0-9._:-]{1,128}")
|
||||
ChatId = Annotated[str, Path(pattern=UUID_PATTERN)]
|
||||
AttachmentId = Annotated[str, Path(pattern=UUID_PATTERN)]
|
||||
IMAGE_TYPES = ("image/png", "image/jpeg")
|
||||
# варианты появятся с lab5; у вложения lab4 их нет, поэтому такой запрос даёт 404, а неизвестное имя 400
|
||||
FUTURE_VARIANTS = ("thumbnail", "crop", "optimized")
|
||||
# символы, которые меняют направление текста и позволяют замаскировать расширение файла
|
||||
BIDI_CONTROLS = set("\u202a\u202b\u202c\u202d\u202e\u2066\u2067\u2068\u2069")
|
||||
|
||||
store = Store(config.database_url())
|
||||
sessions = Sessions(config.cache_url())
|
||||
objects = ObjectStore(config.read_secret("S3_ACCESS_KEY_ID"), config.read_secret("S3_SECRET_ACCESS_KEY"))
|
||||
# загрузки на этой реплике; меняется только в цикле событий, поэтому без блокировки
|
||||
active_uploads = 0
|
||||
# очередь на запись в S3. Асинхронная: ждущая загрузка не занимает поток, текстовые запросы не страдают
|
||||
s3_write_slots = asyncio.Semaphore(config.S3_PARALLEL_WRITES)
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app: FastAPI):
|
||||
store.open()
|
||||
log.info(
|
||||
"started env=%s version=%s instance=%s listen=%s:%d session_ttl=%ds db_pool_max=%d",
|
||||
config.ENV, config.VERSION, config.INSTANCE_ID, config.HOST, config.PORT,
|
||||
config.SESSION_TTL_SECONDS, config.DB_POOL_MAX_SIZE,
|
||||
)
|
||||
yield
|
||||
store.close()
|
||||
sessions.close()
|
||||
log.info("stopped")
|
||||
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger lab4", lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None)
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def request_context(request: Request, call_next):
|
||||
request_id = uuid.uuid4().hex
|
||||
request.state.request_id = request_id
|
||||
started = time.perf_counter()
|
||||
try:
|
||||
response = await call_next(request)
|
||||
except Exception:
|
||||
log.exception("unhandled error request_id=%s", request_id)
|
||||
response = error_response(request_id, 500, "internal_error", "Внутренняя ошибка сервера")
|
||||
response.headers["X-Request-Id"] = request_id
|
||||
response.headers["X-Instance-Id"] = config.INSTANCE_ID
|
||||
# балансировщик проверяет готовность каждую секунду, эти запросы видны только на уровне debug
|
||||
level = logging.DEBUG if request.url.path.startswith("/health/") else logging.INFO
|
||||
# в лог идут только метод, путь и код ответа: тела запросов, пароли и токены не пишем
|
||||
log.log(
|
||||
level, "%s %s status=%d duration_ms=%.1f request_id=%s",
|
||||
request.method, request.url.path, response.status_code,
|
||||
(time.perf_counter() - started) * 1000, request_id,
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
@app.exception_handler(ApiError)
|
||||
async def on_api_error(request: Request, exc: ApiError):
|
||||
return error_response(request.state.request_id, exc.status, exc.code, exc.message, exc.headers)
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def on_validation_error(request: Request, exc: RequestValidationError):
|
||||
first = exc.errors()[0]
|
||||
where = ".".join(str(part) for part in first["loc"])
|
||||
return error_response(request.state.request_id, 400, "invalid_request", f"{where}: {first['msg']}")
|
||||
|
||||
|
||||
@app.exception_handler(HTTPException)
|
||||
async def on_http_error(request: Request, exc: HTTPException):
|
||||
# сюда попадают ошибки самого фреймворка: неизвестный путь, неподдерживаемый метод
|
||||
if exc.status_code == 404:
|
||||
code, message = "not_found", "Объект не найден"
|
||||
else:
|
||||
code, message = "invalid_request", "Запрос не поддерживается"
|
||||
return error_response(request.state.request_id, exc.status_code, code, message, exc.headers)
|
||||
|
||||
|
||||
# OperationalError — нет связи с PostgreSQL, не дождались соединения из пула или сработал statement_timeout
|
||||
@app.exception_handler(psycopg.OperationalError)
|
||||
async def on_database_down(request: Request, exc: Exception):
|
||||
log.warning("postgres unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id)
|
||||
return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен")
|
||||
|
||||
|
||||
@app.exception_handler(redis.RedisError)
|
||||
async def on_cache_down(request: Request, exc: Exception):
|
||||
log.warning("redis unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id)
|
||||
return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен")
|
||||
|
||||
|
||||
@app.exception_handler(BotoCoreError)
|
||||
@app.exception_handler(ClientError)
|
||||
async def on_storage_down(request: Request, exc: Exception):
|
||||
log.warning("s3 unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id)
|
||||
return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен")
|
||||
|
||||
|
||||
@dataclass
|
||||
class Session:
|
||||
user_id: str
|
||||
token: str
|
||||
|
||||
|
||||
def current_session(request: Request) -> Session:
|
||||
# X-User-Id из lab1 здесь не читается вообще, Basic на бизнес-запросах тоже не принимается
|
||||
token = security.parse_bearer(request.headers.get("Authorization"))
|
||||
if token is None:
|
||||
raise unauthorized()
|
||||
# если Redis недоступен, здесь будет исключение и ответ 503: без проверки сессии запрос дальше не идёт
|
||||
user_id = sessions.user_id(token)
|
||||
if user_id is None:
|
||||
raise unauthorized()
|
||||
return Session(user_id, token)
|
||||
|
||||
|
||||
def idempotency_key(request: Request) -> str:
|
||||
key = request.headers.get("Idempotency-Key", "")
|
||||
if not IDEMPOTENCY_KEY.fullmatch(key):
|
||||
raise invalid("Нужен заголовок Idempotency-Key: 1-128 символов A-Z a-z 0-9 . _ : -")
|
||||
return key
|
||||
|
||||
|
||||
def json_body(model):
|
||||
"""Разбирает тело запроса зависимостью, чтобы это происходило после проверки токена."""
|
||||
|
||||
async def parse(request: Request):
|
||||
content_type = request.headers.get("Content-Type", "").split(";")[0].strip().lower()
|
||||
if content_type != "application/json":
|
||||
raise invalid("Нужен Content-Type: application/json")
|
||||
try:
|
||||
raw = bytearray()
|
||||
async for chunk in request.stream():
|
||||
raw += chunk
|
||||
if len(raw) > config.MAX_JSON_BYTES:
|
||||
raise ApiError(413, "payload_too_large", "Слишком большое тело запроса")
|
||||
# decode строгий: контракт допускает только UTF-8, а json.loads сам угадал бы UTF-16
|
||||
data = json.loads(raw.decode("utf-8"))
|
||||
except (ValueError, RecursionError):
|
||||
raise invalid("Тело запроса должно быть корректным JSON в UTF-8")
|
||||
try:
|
||||
return model.model_validate(data)
|
||||
except ValidationError as exc:
|
||||
first = exc.errors()[0]
|
||||
where = ".".join(str(part) for part in ("body", *first["loc"]))
|
||||
raise invalid(f"{where}: {first['msg']}")
|
||||
|
||||
return parse
|
||||
|
||||
|
||||
def member_chat(chat_id: ChatId, session: Session = Depends(current_session)) -> str:
|
||||
"""Чат, в котором состоит текущий пользователь. Посторонний получает 404 до чтения тела запроса."""
|
||||
chat_id = str(UUID(chat_id))
|
||||
if not store.is_member(chat_id, session.user_id):
|
||||
raise not_found()
|
||||
return chat_id
|
||||
|
||||
|
||||
def attachment_filename(filename: Annotated[str, Query(min_length=1, max_length=255)]) -> str:
|
||||
# имя только показывается пользователю, но оно не должно выглядеть как путь или прятать расширение
|
||||
dangerous = any(
|
||||
char in "/\\\ufffd" or char in BIDI_CONTROLS or unicodedata.category(char) == "Cc" for char in filename
|
||||
)
|
||||
if dangerous or not filename.strip() or filename in (".", ".."):
|
||||
raise invalid("Недопустимое имя файла")
|
||||
return filename
|
||||
|
||||
|
||||
async def receive_file(request: Request, target) -> tuple[int, str]:
|
||||
"""Пишет тело запроса во временный файл блоками. В памяти одновременно только текущий блок."""
|
||||
digest = hashlib.sha256()
|
||||
size = 0
|
||||
try:
|
||||
async with asyncio.timeout(config.UPLOAD_TIMEOUT_SECONDS):
|
||||
async for chunk in request.stream():
|
||||
size += len(chunk)
|
||||
if size > config.MAX_UPLOAD_BYTES:
|
||||
raise ApiError(413, "payload_too_large", "Файл больше 10 MiB")
|
||||
digest.update(chunk)
|
||||
target.write(chunk)
|
||||
except TimeoutError:
|
||||
raise invalid("Файл не получен вовремя")
|
||||
except ClientDisconnect:
|
||||
raise invalid("Загрузка прервана")
|
||||
return size, digest.hexdigest()
|
||||
|
||||
|
||||
def save_attachment(staging, chat_id, owner_id, filename, declared_type, size, sha256) -> dict:
|
||||
try:
|
||||
actual_type = images.inspect(staging, config.MAX_IMAGE_PIXELS)
|
||||
except images.NotAnImage:
|
||||
raise ApiError(415, "unsupported_media_type", "Файл не является корректным PNG или JPEG")
|
||||
except images.TooManyPixels:
|
||||
raise ApiError(413, "payload_too_large", "Изображение больше 40 млн пикселей")
|
||||
if actual_type != declared_type:
|
||||
raise ApiError(415, "unsupported_media_type", "Содержимое файла не совпадает с Content-Type")
|
||||
attachment_id = uuid.uuid4()
|
||||
key = f"originals/{attachment_id}"
|
||||
store.create_pending_attachment(attachment_id, chat_id, owner_id, filename, actual_type, size, sha256, key)
|
||||
# объект записан, но вложение ещё не видно: 201 будет только после подтверждения в БД
|
||||
staging.seek(0)
|
||||
objects.put(key, staging, size, actual_type)
|
||||
attachment = store.mark_attachment_ready(attachment_id)
|
||||
if attachment is None:
|
||||
raise ApiError(503, "unavailable", "Сервис временно недоступен")
|
||||
return attachment
|
||||
|
||||
|
||||
def encode_cursor(scope: str, created_at: str, item_id: str) -> str:
|
||||
raw = json.dumps([scope, created_at, item_id])
|
||||
return base64.urlsafe_b64encode(raw.encode()).decode()
|
||||
|
||||
|
||||
def decode_cursor(scope: str, cursor):
|
||||
"""Возвращает ключ (created_at, id) последней выданной записи или None для первой страницы."""
|
||||
if cursor is None:
|
||||
return None
|
||||
try:
|
||||
# validate=True: символ вне алфавита base64 — ошибка, а не пропускается молча
|
||||
cursor_scope, created_at, item_id = json.loads(base64.b64decode(cursor, altchars=b"-_", validate=True))
|
||||
# время и id принимаются только в том виде, в котором их выдаёт сам сервер
|
||||
moment = datetime.strptime(created_at, TIME_FORMAT).replace(tzinfo=timezone.utc)
|
||||
time_ok = moment.strftime(TIME_FORMAT) == created_at
|
||||
id_ok = str(UUID(item_id)) == item_id
|
||||
except (TypeError, ValueError, AttributeError):
|
||||
raise invalid("Некорректный cursor")
|
||||
# cursor действует только для того списка, в котором был выдан
|
||||
if cursor_scope != scope or not time_ok or not id_ok:
|
||||
raise invalid("Некорректный cursor")
|
||||
# у одной позиции есть ровно одна запись cursor: другое оформление JSON или base64 не принимается
|
||||
if encode_cursor(scope, created_at, item_id) != cursor:
|
||||
raise invalid("Некорректный cursor")
|
||||
return [moment, item_id]
|
||||
|
||||
|
||||
def page(scope: str, items: list, has_more: bool) -> dict:
|
||||
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if has_more else None
|
||||
return {"items": items, "next_cursor": next_cursor}
|
||||
|
||||
|
||||
@app.get("/health/live")
|
||||
def liveness():
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.get("/health/ready")
|
||||
def readiness():
|
||||
# без PostgreSQL и Redis обязательные запросы не выполнить, поэтому обе зависимости критичны
|
||||
store.ping()
|
||||
sessions.ping()
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.post("/api/v1/users", status_code=201)
|
||||
def register_user(body: CreateUser = Depends(json_body(CreateUser))):
|
||||
try:
|
||||
return store.create_user(body.username, body.display_name, security.hash_password(body.password))
|
||||
except UsernameTaken:
|
||||
raise ApiError(409, "conflict", "Такой username уже занят")
|
||||
|
||||
|
||||
@app.post("/api/v1/auth/sessions", status_code=201)
|
||||
def create_session(request: Request):
|
||||
credentials = security.parse_basic(request.headers.get("Authorization"))
|
||||
if credentials is None:
|
||||
raise bad_credentials()
|
||||
username, password = credentials
|
||||
user, password_hash = None, None
|
||||
# username, который не мог быть зарегистрирован, в БД не ищем, но пароль всё равно сверяем с пустышкой
|
||||
if USERNAME.fullmatch(username):
|
||||
user, password_hash = store.get_credentials(username)
|
||||
if not security.verify_password(password_hash, password):
|
||||
raise bad_credentials()
|
||||
token = sessions.create(user["id"])
|
||||
expires_at = datetime.now(timezone.utc) + timedelta(seconds=config.SESSION_TTL_SECONDS)
|
||||
return {"token": token, "token_type": "Bearer", "expires_at": timestamp(expires_at), "user": user}
|
||||
|
||||
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
def revoke_session(session: Session = Depends(current_session)):
|
||||
sessions.revoke(session.token)
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@app.get("/api/v1/users/me")
|
||||
def get_me(session: Session = Depends(current_session)):
|
||||
user = store.get_user(session.user_id)
|
||||
if user is None:
|
||||
raise unauthorized()
|
||||
return user
|
||||
|
||||
|
||||
@app.post("/api/v1/chats", status_code=201)
|
||||
def create_chat(session: Session = Depends(current_session), body: CreateChat = Depends(json_body(CreateChat))):
|
||||
member_ids = [str(UUID(member)) for member in body.member_ids]
|
||||
if len(set(member_ids)) != len(member_ids):
|
||||
raise invalid("member_ids содержит повторы")
|
||||
if session.user_id not in member_ids:
|
||||
raise invalid("Создатель чата должен быть в member_ids")
|
||||
try:
|
||||
return store.create_chat(body.title, member_ids)
|
||||
except UnknownMember:
|
||||
raise invalid("В member_ids есть несуществующий пользователь")
|
||||
|
||||
|
||||
@app.get("/api/v1/chats")
|
||||
def list_chats(
|
||||
limit: int = Query(50, ge=1, le=100),
|
||||
cursor: str | None = Query(None, min_length=1),
|
||||
session: Session = Depends(current_session),
|
||||
):
|
||||
scope = "chats:" + session.user_id
|
||||
items, has_more = store.list_chats(session.user_id, decode_cursor(scope, cursor), limit)
|
||||
return page(scope, items, has_more)
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}")
|
||||
def get_chat(chat_id: ChatId, session: Session = Depends(current_session)):
|
||||
chat = store.get_chat(str(UUID(chat_id)), session.user_id)
|
||||
if chat is None:
|
||||
raise not_found()
|
||||
return chat
|
||||
|
||||
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
||||
def send_message(
|
||||
chat_id: ChatId,
|
||||
session: Session = Depends(current_session),
|
||||
key: str = Depends(idempotency_key),
|
||||
body: CreateMessage = Depends(json_body(CreateMessage)),
|
||||
):
|
||||
# отправитель берётся из сессии, в теле запроса его нет
|
||||
try:
|
||||
attachment_ids = [str(UUID(item)) for item in body.attachment_ids]
|
||||
message = store.add_message(str(UUID(chat_id)), session.user_id, body.text, attachment_ids, key)
|
||||
except IdempotencyConflict:
|
||||
raise ApiError(409, "conflict", "Этот Idempotency-Key уже использован с другим сообщением")
|
||||
except UnknownAttachment:
|
||||
raise not_found()
|
||||
if message is None:
|
||||
raise not_found()
|
||||
return message
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}/messages")
|
||||
def list_messages(
|
||||
chat_id: ChatId,
|
||||
limit: int = Query(50, ge=1, le=100),
|
||||
cursor: str | None = Query(None, min_length=1),
|
||||
session: Session = Depends(current_session),
|
||||
):
|
||||
chat_id = str(UUID(chat_id))
|
||||
scope = "messages:" + chat_id
|
||||
result = store.list_messages(chat_id, session.user_id, decode_cursor(scope, cursor), limit)
|
||||
if result is None:
|
||||
raise not_found()
|
||||
items, has_more = result
|
||||
return page(scope, items, has_more)
|
||||
|
||||
|
||||
@app.post("/api/v1/chats/{chat_id}/attachments", status_code=201)
|
||||
async def upload_attachment(
|
||||
request: Request,
|
||||
session: Session = Depends(current_session),
|
||||
chat_id: str = Depends(member_chat),
|
||||
filename: str = Depends(attachment_filename),
|
||||
):
|
||||
global active_uploads
|
||||
declared_type = request.headers.get("Content-Type", "").split(";")[0].strip().lower()
|
||||
if declared_type not in IMAGE_TYPES:
|
||||
raise ApiError(415, "unsupported_media_type", "Нужен Content-Type: image/png или image/jpeg")
|
||||
length = request.headers.get("Content-Length", "")
|
||||
if length.isdigit() and int(length) > config.MAX_UPLOAD_BYTES:
|
||||
raise ApiError(413, "payload_too_large", "Файл больше 10 MiB")
|
||||
if active_uploads >= config.MAX_PARALLEL_UPLOADS:
|
||||
raise ApiError(429, "rate_limited", "Слишком много одновременных загрузок", {"Retry-After": "1"})
|
||||
active_uploads += 1
|
||||
try:
|
||||
# временный файл без имени: система удалит его при любом завершении процесса
|
||||
with tempfile.TemporaryFile() as staging:
|
||||
size, sha256 = await receive_file(request, staging)
|
||||
if size == 0:
|
||||
raise ApiError(415, "unsupported_media_type", "Файл пуст")
|
||||
try:
|
||||
async with asyncio.timeout(config.S3_WRITE_QUEUE_SECONDS):
|
||||
await s3_write_slots.acquire()
|
||||
except TimeoutError:
|
||||
raise ApiError(503, "unavailable", "Сервис временно недоступен")
|
||||
try:
|
||||
return await run_in_threadpool(
|
||||
save_attachment, staging, chat_id, session.user_id, filename, declared_type, size, sha256
|
||||
)
|
||||
finally:
|
||||
s3_write_slots.release()
|
||||
finally:
|
||||
active_uploads -= 1
|
||||
|
||||
|
||||
@app.get("/api/v1/attachments/{attachment_id}")
|
||||
def get_attachment(attachment_id: AttachmentId, session: Session = Depends(current_session)):
|
||||
attachment, _ = store.get_attachment(str(UUID(attachment_id)), session.user_id)
|
||||
if attachment is None:
|
||||
raise not_found()
|
||||
return attachment
|
||||
|
||||
|
||||
@app.get("/api/v1/attachments/{attachment_id}/content")
|
||||
def download_attachment(
|
||||
attachment_id: AttachmentId,
|
||||
variant: str = Query("original"),
|
||||
session: Session = Depends(current_session),
|
||||
):
|
||||
# доступ проверяет приложение: bucket приватный, и случайный ключ объекта правом доступа не является
|
||||
attachment, key = store.get_attachment(str(UUID(attachment_id)), session.user_id)
|
||||
if attachment is None or variant in FUTURE_VARIANTS:
|
||||
raise not_found()
|
||||
if variant != "original":
|
||||
raise invalid("Неизвестный variant")
|
||||
body = objects.open(key)
|
||||
|
||||
def stream():
|
||||
try:
|
||||
yield from body.iter_chunks(64 * 1024)
|
||||
finally:
|
||||
body.close()
|
||||
|
||||
headers = {
|
||||
"Content-Length": str(attachment["size_bytes"]),
|
||||
"Content-Disposition": "attachment; filename*=UTF-8''" + quote(attachment["filename"], safe=""),
|
||||
"X-Content-Type-Options": "nosniff",
|
||||
"Cache-Control": "private, no-store",
|
||||
}
|
||||
return StreamingResponse(stream(), media_type=attachment["content_type"], headers=headers)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
uvicorn.run(
|
||||
app,
|
||||
host=config.HOST,
|
||||
port=config.PORT,
|
||||
log_level=config.LOG_LEVEL,
|
||||
access_log=False,
|
||||
timeout_graceful_shutdown=config.SHUTDOWN_TIMEOUT,
|
||||
)
|
||||
@@ -0,0 +1,48 @@
|
||||
"""Применяет SQL-миграции из каталога migrations по порядку имён. Повторный запуск ничего не меняет."""
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import psycopg
|
||||
|
||||
import config
|
||||
|
||||
MIGRATIONS_DIR = Path(os.getenv("MIGRATIONS_DIR", "migrations"))
|
||||
LOCK_ID = 20260201 # любое постоянное число: два мигратора не должны работать одновременно
|
||||
|
||||
|
||||
def connect(attempts=30):
|
||||
for attempt in range(attempts):
|
||||
try:
|
||||
return psycopg.connect(config.database_url(), autocommit=True, connect_timeout=config.DB_CONNECT_TIMEOUT)
|
||||
except psycopg.OperationalError:
|
||||
if attempt == attempts - 1:
|
||||
raise
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
def main():
|
||||
files = sorted(MIGRATIONS_DIR.glob("*.sql"))
|
||||
if not files:
|
||||
sys.exit(f"в {MIGRATIONS_DIR} нет миграций")
|
||||
with connect() as conn:
|
||||
conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,))
|
||||
conn.execute(
|
||||
"CREATE TABLE IF NOT EXISTS schema_migrations ("
|
||||
"version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())"
|
||||
)
|
||||
applied = {row[0] for row in conn.execute("SELECT version FROM schema_migrations")}
|
||||
for path in files:
|
||||
if path.name in applied:
|
||||
print("уже применена:", path.name)
|
||||
continue
|
||||
# миграция и отметка о ней в одной транзакции: либо всё, либо ничего
|
||||
with conn.transaction():
|
||||
conn.execute(path.read_text())
|
||||
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,))
|
||||
print("применена:", path.name)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,46 @@
|
||||
import boto3
|
||||
from botocore.config import Config
|
||||
|
||||
import config
|
||||
|
||||
|
||||
class ObjectStore:
|
||||
"""Байты вложений в приватном bucket. Какие операции разрешены, решают права конкретного ключа."""
|
||||
|
||||
def __init__(self, access_key: str, secret_key: str):
|
||||
self.bucket = config.S3_BUCKET
|
||||
self.client = boto3.client(
|
||||
"s3",
|
||||
endpoint_url=config.S3_ENDPOINT,
|
||||
region_name=config.S3_REGION,
|
||||
aws_access_key_id=access_key,
|
||||
aws_secret_access_key=secret_key,
|
||||
config=Config(
|
||||
signature_version="s3v4",
|
||||
s3={"addressing_style": "path"},
|
||||
connect_timeout=config.S3_CONNECT_TIMEOUT,
|
||||
read_timeout=config.S3_READ_TIMEOUT,
|
||||
# без повторов: иначе время ответа при отказе складывается и выходит за timeout server балансировщика
|
||||
retries={"total_max_attempts": 1},
|
||||
max_pool_connections=config.S3_POOL_SIZE,
|
||||
# контрольные суммы протокола выключены: целостность проверяет sha256 приложения
|
||||
request_checksum_calculation="when_required",
|
||||
response_checksum_validation="when_required",
|
||||
),
|
||||
)
|
||||
|
||||
def put(self, key: str, file, size: int, content_type: str) -> None:
|
||||
# из файла, а не из памяти: boto3 читает его блоками
|
||||
self.client.put_object(Bucket=self.bucket, Key=key, Body=file, ContentLength=size, ContentType=content_type)
|
||||
|
||||
def open(self, key: str):
|
||||
return self.client.get_object(Bucket=self.bucket, Key=key)["Body"]
|
||||
|
||||
def delete(self, key: str) -> None:
|
||||
self.client.delete_object(Bucket=self.bucket, Key=key)
|
||||
|
||||
def pages(self):
|
||||
"""Объекты bucket страницами, чтобы не держать весь список в памяти."""
|
||||
paginator = self.client.get_paginator("list_objects_v2")
|
||||
for page in paginator.paginate(Bucket=self.bucket):
|
||||
yield page.get("Contents", [])
|
||||
@@ -0,0 +1,41 @@
|
||||
"""Создаёт приватный bucket и проверяет его пробной записью. Повторный запуск ничего не меняет.
|
||||
|
||||
На пустом хранилище первая запись запускает создание томов, это занимает больше таймаута API.
|
||||
Пробная запись делает это до старта реплик, иначе первая загрузка пользователя получила бы 503.
|
||||
"""
|
||||
import sys
|
||||
import time
|
||||
|
||||
from botocore.exceptions import BotoCoreError, ClientError
|
||||
|
||||
import config
|
||||
from objects import ObjectStore
|
||||
|
||||
|
||||
PROBE_KEY = "bootstrap/probe"
|
||||
|
||||
|
||||
def main():
|
||||
store = ObjectStore(config.read_secret("S3_ADMIN_ACCESS_KEY_ID"), config.read_secret("S3_ADMIN_SECRET_ACCESS_KEY"))
|
||||
for attempt in range(30):
|
||||
try:
|
||||
existing = [bucket["Name"] for bucket in store.client.list_buckets().get("Buckets", [])]
|
||||
if store.bucket in existing:
|
||||
print("bucket уже есть:", store.bucket)
|
||||
else:
|
||||
# без ACL и политик: доступ есть только у ключей из конфигурации S3-сервера
|
||||
store.client.create_bucket(Bucket=store.bucket)
|
||||
print("bucket создан:", store.bucket)
|
||||
store.client.put_object(Bucket=store.bucket, Key=PROBE_KEY, Body=b"probe")
|
||||
store.client.get_object(Bucket=store.bucket, Key=PROBE_KEY)["Body"].read()
|
||||
store.delete(PROBE_KEY)
|
||||
print("пробная запись прошла")
|
||||
return
|
||||
except (BotoCoreError, ClientError) as error:
|
||||
print("S3 ещё не готов:", type(error).__name__, flush=True)
|
||||
time.sleep(1)
|
||||
sys.exit("S3 не ответил за 30 попыток")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,55 @@
|
||||
from typing import Annotated
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
|
||||
|
||||
# только запись 8-4-4-4-12: UUID из Python принял бы ещё скобки, urn: и строку без дефисов
|
||||
UUID_PATTERN = r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
|
||||
Uuid = Annotated[str, Field(pattern=UUID_PATTERN)]
|
||||
|
||||
|
||||
def storable(value: str) -> str:
|
||||
# PostgreSQL не хранит символ NUL в text, а одиночные суррогаты нельзя записать в UTF-8
|
||||
if "\x00" in value or any(0xD800 <= ord(char) <= 0xDFFF for char in value):
|
||||
raise ValueError("строка содержит недопустимые символы")
|
||||
return value
|
||||
|
||||
|
||||
def not_blank(value: str) -> str:
|
||||
if not value.strip():
|
||||
raise ValueError("строка не может состоять только из пробелов")
|
||||
return storable(value)
|
||||
|
||||
|
||||
class StrictModel(BaseModel):
|
||||
# лишние поля в JSON считаются ошибкой
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
|
||||
class CreateUser(StrictModel):
|
||||
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
|
||||
display_name: str = Field(min_length=1, max_length=100)
|
||||
password: str = Field(min_length=12, max_length=128)
|
||||
|
||||
_not_blank = field_validator("display_name", "password")(not_blank)
|
||||
|
||||
|
||||
class CreateChat(StrictModel):
|
||||
title: str = Field(min_length=1, max_length=100)
|
||||
member_ids: list[Uuid] = Field(min_length=1, max_length=100)
|
||||
|
||||
_title = field_validator("title")(not_blank)
|
||||
|
||||
|
||||
class CreateMessage(StrictModel):
|
||||
text: str = Field(max_length=4000)
|
||||
attachment_ids: list[Uuid] = Field(default_factory=list, max_length=10)
|
||||
|
||||
_text = field_validator("text")(storable)
|
||||
|
||||
@model_validator(mode="after")
|
||||
def text_or_attachment(self):
|
||||
if not self.text.strip() and not self.attachment_ids:
|
||||
raise ValueError("нужен текст или хотя бы одно вложение")
|
||||
if len({item.lower() for item in self.attachment_ids}) != len(self.attachment_ids):
|
||||
raise ValueError("attachment_ids содержит повторы")
|
||||
return self
|
||||
@@ -0,0 +1,45 @@
|
||||
import base64
|
||||
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import InvalidHashError, VerificationError
|
||||
|
||||
# Argon2id, параметры из рекомендаций OWASP: 19 МиБ памяти, 2 прохода, 1 поток
|
||||
hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
|
||||
# с этим hash сверяется пароль, когда пользователя нет: время ответа не выдаёт, существует ли username
|
||||
DUMMY_HASH = hasher.hash("no-such-user-password")
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
return hasher.hash(password)
|
||||
|
||||
|
||||
def verify_password(password_hash, password: str) -> bool:
|
||||
try:
|
||||
return hasher.verify(password_hash or DUMMY_HASH, password) and password_hash is not None
|
||||
except (VerificationError, InvalidHashError):
|
||||
return False
|
||||
|
||||
|
||||
def parse_basic(header):
|
||||
"""Разбирает Authorization: Basic base64(username:password). Возвращает пару или None."""
|
||||
scheme, _, value = (header or "").partition(" ")
|
||||
if scheme.lower() != "basic":
|
||||
return None
|
||||
try:
|
||||
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
|
||||
except ValueError:
|
||||
# три случая сразу: не ASCII в заголовке (сам ValueError), неверный base64 и байты не в UTF-8
|
||||
# (их исключения — подклассы ValueError)
|
||||
return None
|
||||
# двоеточие в пароле допустимо, поэтому делим только по первому
|
||||
username, colon, password = decoded.partition(":")
|
||||
if not colon:
|
||||
return None
|
||||
return username, password
|
||||
|
||||
|
||||
def parse_bearer(header):
|
||||
scheme, _, token = (header or "").partition(" ")
|
||||
if scheme.lower() != "bearer" or not token.strip():
|
||||
return None
|
||||
return token.strip()
|
||||
@@ -0,0 +1,47 @@
|
||||
import hashlib
|
||||
import secrets
|
||||
|
||||
import redis
|
||||
from redis.backoff import NoBackoff
|
||||
from redis.retry import Retry
|
||||
|
||||
import config
|
||||
|
||||
|
||||
class Sessions:
|
||||
"""Сессии лежат только в Redis: ключ session:<sha256 токена>, значение id пользователя, TTL ставит сам Redis."""
|
||||
|
||||
def __init__(self, url: str):
|
||||
pool = redis.BlockingConnectionPool.from_url(
|
||||
url,
|
||||
max_connections=config.CACHE_POOL_MAX_SIZE,
|
||||
timeout=config.CACHE_TIMEOUT, # ожидание свободного соединения
|
||||
socket_timeout=config.CACHE_TIMEOUT,
|
||||
socket_connect_timeout=config.CACHE_TIMEOUT,
|
||||
decode_responses=True,
|
||||
# одна повторная попытка без паузы: её хватает после перезапуска Redis, а при отказе ответ не затягивается
|
||||
retry=Retry(NoBackoff(), 1),
|
||||
)
|
||||
self.client = redis.Redis(connection_pool=pool)
|
||||
|
||||
@staticmethod
|
||||
def key(token: str) -> str:
|
||||
# сам токен в Redis не хранится: по дампу нельзя войти от чужого имени
|
||||
return "session:" + hashlib.sha256(token.encode()).hexdigest()
|
||||
|
||||
def create(self, user_id: str) -> str:
|
||||
token = secrets.token_urlsafe(32) # 256 бит случайности
|
||||
self.client.set(self.key(token), user_id, ex=config.SESSION_TTL_SECONDS)
|
||||
return token
|
||||
|
||||
def user_id(self, token: str):
|
||||
return self.client.get(self.key(token))
|
||||
|
||||
def revoke(self, token: str) -> None:
|
||||
self.client.delete(self.key(token))
|
||||
|
||||
def ping(self) -> None:
|
||||
self.client.ping()
|
||||
|
||||
def close(self) -> None:
|
||||
self.client.close()
|
||||
+298
@@ -0,0 +1,298 @@
|
||||
import uuid
|
||||
from datetime import timezone
|
||||
|
||||
from psycopg import errors
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import ConnectionPool
|
||||
|
||||
import config
|
||||
|
||||
|
||||
class UsernameTaken(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class UnknownMember(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class IdempotencyConflict(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class UnknownAttachment(Exception):
|
||||
pass
|
||||
|
||||
|
||||
# ширина строки фиксированная: 6 знаков микросекунд, столько же хранит timestamptz
|
||||
TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
|
||||
|
||||
|
||||
def timestamp(value) -> str:
|
||||
return value.astimezone(timezone.utc).strftime(TIME_FORMAT)
|
||||
|
||||
|
||||
def user_json(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"username": row["username"],
|
||||
"display_name": row["display_name"],
|
||||
"created_at": timestamp(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def chat_json(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"title": row["title"],
|
||||
"member_ids": [str(member) for member in row["member_ids"]],
|
||||
"created_at": timestamp(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def message_json(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"chat_id": str(row["chat_id"]),
|
||||
"sender_id": str(row["sender_id"]),
|
||||
"text": row["text"],
|
||||
"created_at": timestamp(row["created_at"]),
|
||||
"attachment_ids": [str(item) for item in row["attachment_ids"]],
|
||||
}
|
||||
|
||||
|
||||
def attachment_json(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"chat_id": str(row["chat_id"]),
|
||||
"owner_id": str(row["owner_id"]),
|
||||
"filename": row["filename"],
|
||||
"content_type": row["content_type"],
|
||||
"size_bytes": row["size_bytes"],
|
||||
"sha256": row["sha256"],
|
||||
"status": "ready",
|
||||
"variants": [],
|
||||
"error_code": None,
|
||||
"created_at": timestamp(row["created_at"]),
|
||||
"updated_at": timestamp(row["updated_at"]),
|
||||
}
|
||||
|
||||
|
||||
CHAT_COLUMNS = """
|
||||
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) AS member_ids
|
||||
"""
|
||||
|
||||
|
||||
MESSAGE_COLUMNS = """
|
||||
m.id, m.chat_id, m.sender_id, m.text, m.created_at,
|
||||
COALESCE((SELECT array_agg(a.attachment_id ORDER BY a.position) FROM message_attachments a
|
||||
WHERE a.message_id = m.id), '{}'::uuid[]) AS attachment_ids
|
||||
"""
|
||||
|
||||
ATTACHMENT_COLUMNS = "a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, a.created_at, a.updated_at"
|
||||
|
||||
|
||||
class Store:
|
||||
"""Все данные мессенджера в PostgreSQL. Значения в запросы попадают только через параметры %s."""
|
||||
|
||||
def __init__(self, url: str):
|
||||
self.pool = ConnectionPool(
|
||||
url,
|
||||
min_size=config.DB_POOL_MIN_SIZE,
|
||||
max_size=config.DB_POOL_MAX_SIZE,
|
||||
timeout=config.DB_POOL_TIMEOUT, # сколько запрос ждёт свободное соединение
|
||||
kwargs={
|
||||
"connect_timeout": config.DB_CONNECT_TIMEOUT,
|
||||
"options": f"-c statement_timeout={config.DB_STATEMENT_TIMEOUT * 1000}",
|
||||
"row_factory": dict_row,
|
||||
},
|
||||
# перед выдачей соединение проверяется, поэтому после перезапуска БД мёртвые соединения не достаются запросам
|
||||
check=ConnectionPool.check_connection,
|
||||
open=False,
|
||||
)
|
||||
|
||||
def open(self) -> None:
|
||||
# не ждём БД: если она недоступна, сервер стартует и отвечает 503
|
||||
self.pool.open(wait=False)
|
||||
|
||||
def close(self) -> None:
|
||||
self.pool.close()
|
||||
|
||||
def ping(self) -> None:
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute("SELECT 1")
|
||||
|
||||
def create_user(self, username: str, display_name: str, password_hash: str) -> dict:
|
||||
with self.pool.connection() as conn:
|
||||
try:
|
||||
row = conn.execute(
|
||||
"INSERT INTO users (username, display_name, password_hash) VALUES (%s, %s, %s) "
|
||||
"RETURNING id, username, display_name, created_at",
|
||||
(username, display_name, password_hash),
|
||||
).fetchone()
|
||||
except errors.UniqueViolation:
|
||||
# уникальность проверяет сама БД, поэтому два одновременных запроса не создадут двух пользователей
|
||||
raise UsernameTaken()
|
||||
return user_json(row)
|
||||
|
||||
def get_user(self, user_id: str):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"SELECT id, username, display_name, created_at FROM users WHERE id = %s", (user_id,)
|
||||
).fetchone()
|
||||
return user_json(row) if row else None
|
||||
|
||||
def get_credentials(self, username: str):
|
||||
"""Пользователь и hash его пароля или (None, None)."""
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
|
||||
(username,),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
return None, None
|
||||
return user_json(row), row["password_hash"]
|
||||
|
||||
def create_chat(self, title: str, member_ids: list) -> dict:
|
||||
# блок with — одна транзакция: commit при выходе, rollback при любом исключении
|
||||
with self.pool.connection() as conn:
|
||||
chat = conn.execute(
|
||||
"INSERT INTO chats (title) VALUES (%s) RETURNING id, title, created_at", (title,)
|
||||
).fetchone()
|
||||
try:
|
||||
with conn.cursor() as cursor:
|
||||
cursor.executemany(
|
||||
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
|
||||
[(chat["id"], member, position) for position, member in enumerate(member_ids)],
|
||||
)
|
||||
except errors.ForeignKeyViolation:
|
||||
# участника нет в users: транзакция откатывается вместе с уже вставленным чатом
|
||||
raise UnknownMember()
|
||||
return chat_json({**chat, "member_ids": member_ids})
|
||||
|
||||
def get_chat(self, chat_id: str, user_id: str):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
f"SELECT {CHAT_COLUMNS} FROM chats c "
|
||||
"JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s WHERE c.id = %s",
|
||||
(user_id, chat_id),
|
||||
).fetchone()
|
||||
return chat_json(row) if row else None
|
||||
|
||||
def list_chats(self, user_id: str, after, limit: int):
|
||||
query = f"SELECT {CHAT_COLUMNS} FROM chats c JOIN chat_members me ON me.chat_id = c.id WHERE me.user_id = %s"
|
||||
params = [user_id]
|
||||
if after:
|
||||
query += " AND (c.created_at, c.id) > (%s, %s)"
|
||||
params += after
|
||||
query += " ORDER BY c.created_at, c.id LIMIT %s"
|
||||
with self.pool.connection() as conn:
|
||||
rows = conn.execute(query, params + [limit + 1]).fetchall()
|
||||
return [chat_json(row) for row in rows[:limit]], len(rows) > limit
|
||||
|
||||
def add_message(self, chat_id: str, sender_id: str, text: str, attachment_ids: list, key: str):
|
||||
"""Отправляет сообщение один раз на ключ. Повтор с тем же телом возвращает исходное сообщение."""
|
||||
message_id = uuid.uuid4()
|
||||
# ключ, сообщение и ссылки на вложения пишутся в одной транзакции: при сбое не остаётся ничего
|
||||
with self.pool.connection() as conn:
|
||||
if not self._is_member(conn, chat_id, sender_id):
|
||||
return None
|
||||
# параллельный запрос с тем же ключом ждёт здесь, пока первая транзакция не завершится;
|
||||
# строка возвращается, только если ключ свободен или его срок вышел
|
||||
claimed = conn.execute(
|
||||
"INSERT INTO idempotency_keys (user_id, chat_id, key, message_id) VALUES (%s, %s, %s, %s) "
|
||||
"ON CONFLICT (user_id, chat_id, key) DO UPDATE "
|
||||
"SET message_id = EXCLUDED.message_id, created_at = now() "
|
||||
"WHERE idempotency_keys.created_at < now() - make_interval(secs => %s) "
|
||||
"RETURNING message_id",
|
||||
(sender_id, chat_id, key, message_id, config.IDEMPOTENCY_TTL_SECONDS),
|
||||
).fetchone()
|
||||
if claimed:
|
||||
self._check_attachments(conn, chat_id, attachment_ids)
|
||||
conn.execute(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s)",
|
||||
(message_id, chat_id, sender_id, text),
|
||||
)
|
||||
if attachment_ids:
|
||||
with conn.cursor() as cursor:
|
||||
cursor.executemany(
|
||||
"INSERT INTO message_attachments (message_id, attachment_id, position) VALUES (%s, %s, %s)",
|
||||
[(message_id, item, position) for position, item in enumerate(attachment_ids)],
|
||||
)
|
||||
row = conn.execute(
|
||||
f"SELECT {MESSAGE_COLUMNS} FROM idempotency_keys k JOIN messages m ON m.id = k.message_id "
|
||||
"WHERE k.user_id = %s AND k.chat_id = %s AND k.key = %s",
|
||||
(sender_id, chat_id, key),
|
||||
).fetchone()
|
||||
message = message_json(row)
|
||||
if message["text"] != text or message["attachment_ids"] != attachment_ids:
|
||||
raise IdempotencyConflict()
|
||||
return message
|
||||
|
||||
@staticmethod
|
||||
def _check_attachments(conn, chat_id: str, attachment_ids: list) -> None:
|
||||
"""Все вложения должны быть готовы и лежать в этом чате; исключение откатывает транзакцию с ключом."""
|
||||
if not attachment_ids:
|
||||
return
|
||||
found = conn.execute(
|
||||
"SELECT count(*) AS total FROM attachments WHERE id = ANY(%s::uuid[]) AND chat_id = %s AND state = 'ready'",
|
||||
(attachment_ids, chat_id),
|
||||
).fetchone()
|
||||
if found["total"] != len(attachment_ids):
|
||||
raise UnknownAttachment()
|
||||
|
||||
def create_pending_attachment(self, attachment_id, chat_id, owner_id, filename, content_type, size, sha256, key) -> None:
|
||||
# строка записывается до объекта: так в S3 не появится объект, о котором не знает БД
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute(
|
||||
"INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key, state) "
|
||||
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, 'pending')",
|
||||
(attachment_id, chat_id, owner_id, filename, content_type, size, sha256, key),
|
||||
)
|
||||
|
||||
def mark_attachment_ready(self, attachment_id):
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"UPDATE attachments a SET state = 'ready', updated_at = now() "
|
||||
f"WHERE a.id = %s AND a.state = 'pending' RETURNING {ATTACHMENT_COLUMNS}",
|
||||
(attachment_id,),
|
||||
).fetchone()
|
||||
return attachment_json(row) if row else None
|
||||
|
||||
def get_attachment(self, attachment_id: str, user_id: str):
|
||||
"""Готовое вложение и его object_key, если пользователь состоит в чате."""
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
f"SELECT {ATTACHMENT_COLUMNS}, a.object_key FROM attachments a "
|
||||
"JOIN chat_members me ON me.chat_id = a.chat_id AND me.user_id = %s "
|
||||
"WHERE a.id = %s AND a.state = 'ready'",
|
||||
(user_id, attachment_id),
|
||||
).fetchone()
|
||||
return (attachment_json(row), row["object_key"]) if row else (None, None)
|
||||
|
||||
def is_member(self, chat_id: str, user_id: str) -> bool:
|
||||
with self.pool.connection() as conn:
|
||||
return self._is_member(conn, chat_id, user_id)
|
||||
|
||||
def list_messages(self, chat_id: str, user_id: str, after, limit: int):
|
||||
query = f"SELECT {MESSAGE_COLUMNS} FROM messages m WHERE m.chat_id = %s"
|
||||
params = [chat_id]
|
||||
if after:
|
||||
# keyset: продолжаем с записи после cursor, а не пропускаем N строк
|
||||
query += " AND (m.created_at, m.id) > (%s, %s)"
|
||||
params += after
|
||||
query += " ORDER BY m.created_at, m.id LIMIT %s"
|
||||
with self.pool.connection() as conn:
|
||||
if not self._is_member(conn, chat_id, user_id):
|
||||
return None
|
||||
# limit + 1: лишняя строка показывает, есть ли следующая страница
|
||||
rows = conn.execute(query, params + [limit + 1]).fetchall()
|
||||
return [message_json(row) for row in rows[:limit]], len(rows) > limit
|
||||
|
||||
@staticmethod
|
||||
def _is_member(conn, chat_id: str, user_id: str) -> bool:
|
||||
row = conn.execute(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user_id)
|
||||
).fetchone()
|
||||
return row is not None
|
||||
@@ -0,0 +1,102 @@
|
||||
"""Маленький HTTP-клиент для собственных тестов. Только стандартная библиотека."""
|
||||
import base64
|
||||
import json
|
||||
import os
|
||||
import urllib.error
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/")
|
||||
|
||||
|
||||
def call(method, path, body=None, user=None, raw=None, headers=None, base_url=None, timeout=15):
|
||||
"""Возвращает (код ответа, разобранный JSON или None, заголовки)."""
|
||||
request_headers = {"Accept": "application/json"}
|
||||
if body is not None:
|
||||
raw = json.dumps(body, ensure_ascii=False).encode("utf-8")
|
||||
if raw is not None:
|
||||
request_headers["Content-Type"] = "application/json"
|
||||
if user is not None:
|
||||
request_headers["Authorization"] = "Bearer " + user["token"]
|
||||
request_headers.update(headers or {})
|
||||
request = urllib.request.Request((base_url or BASE_URL) + path, data=raw, headers=request_headers, method=method)
|
||||
try:
|
||||
response = urllib.request.urlopen(request, timeout=timeout)
|
||||
except urllib.error.HTTPError as error:
|
||||
response = error
|
||||
with response:
|
||||
data = response.read()
|
||||
return response.status, json.loads(data) if data else None, response.headers
|
||||
|
||||
|
||||
def basic(username, password):
|
||||
return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode("utf-8")).decode()}
|
||||
|
||||
|
||||
def login(username, password, base_url=None):
|
||||
return call("POST", "/api/v1/auth/sessions", headers=basic(username, password), base_url=base_url)
|
||||
|
||||
|
||||
def user_body(**fields):
|
||||
"""Корректное тело регистрации со случайным username; поля можно переопределить."""
|
||||
body = {"username": "u_" + uuid.uuid4().hex[:12], "display_name": "Тест", "password": "Pw-" + uuid.uuid4().hex}
|
||||
body.update(fields)
|
||||
return body
|
||||
|
||||
|
||||
def new_user(prefix="t", base_url=None):
|
||||
"""Регистрирует синтетического пользователя и сразу входит. В словаре id, username, password и token."""
|
||||
body = user_body(username=prefix + "_" + uuid.uuid4().hex[:12], display_name="Тест " + prefix)
|
||||
status, user, _ = call("POST", "/api/v1/users", body, base_url=base_url)
|
||||
assert status == 201, status
|
||||
status, session, _ = login(body["username"], body["password"], base_url=base_url)
|
||||
assert status == 201, status
|
||||
return {**user, "password": body["password"], "token": session["token"], "user": user}
|
||||
|
||||
|
||||
def new_chat(owner, *others, title="Тестовый чат"):
|
||||
member_ids = [owner["id"]] + [other["id"] for other in others]
|
||||
status, chat, _ = call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=owner)
|
||||
assert status == 201, status
|
||||
return chat
|
||||
|
||||
|
||||
def new_key():
|
||||
return uuid.uuid4().hex
|
||||
|
||||
|
||||
def send(user, chat, text, key=None, attachment_ids=None, **options):
|
||||
headers = {"Idempotency-Key": key or new_key()}
|
||||
body = {"text": text}
|
||||
if attachment_ids is not None:
|
||||
body["attachment_ids"] = attachment_ids
|
||||
return call("POST", "/api/v1/chats/" + chat["id"] + "/messages", body, user=user, headers=headers, **options)
|
||||
|
||||
|
||||
def request_bytes(method, path, user=None, base_url=None, timeout=15):
|
||||
"""Как call, но ответ не разбирается как JSON: для скачивания файлов."""
|
||||
headers = {"Authorization": "Bearer " + user["token"]} if user else {}
|
||||
request = urllib.request.Request((base_url or BASE_URL) + path, headers=headers, method=method)
|
||||
try:
|
||||
response = urllib.request.urlopen(request, timeout=timeout)
|
||||
except urllib.error.HTTPError as error:
|
||||
response = error
|
||||
with response:
|
||||
return response.status, response.read(), response.headers
|
||||
|
||||
|
||||
def history(user, chat, limit):
|
||||
"""Обходит всю историю чата страницами по limit, возвращает сообщения и размеры страниц."""
|
||||
items, sizes, cursor = [], [], None
|
||||
while True:
|
||||
path = "/api/v1/chats/%s/messages?limit=%d" % (chat["id"], limit)
|
||||
if cursor:
|
||||
path += "&cursor=" + urllib.parse.quote(cursor, safe="")
|
||||
status, page, _ = call("GET", path, user=user)
|
||||
assert status == 200, status
|
||||
items += page["items"]
|
||||
sizes.append(len(page["items"]))
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
return items, sizes
|
||||
@@ -0,0 +1,49 @@
|
||||
"""Управление стендом для тестов отказов: останавливает и запускает сервисы через docker compose."""
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(ROOT / "student-tests"))
|
||||
|
||||
from api import BASE_URL, call # noqa: E402
|
||||
|
||||
|
||||
def compose(*args):
|
||||
command = ["docker", "compose", "--env-file", ".env", "-f", "compose.yaml", "-f", "compose.test.yaml", *args]
|
||||
result = subprocess.run(command, cwd=ROOT, capture_output=True, text=True)
|
||||
if result.returncode:
|
||||
raise AssertionError("compose %s: %s" % (" ".join(args[:4]), result.stderr[-600:]))
|
||||
return result.stdout
|
||||
|
||||
|
||||
def sql(query):
|
||||
"""Выполняет запрос через psql внутри контейнера postgres и возвращает вывод без оформления."""
|
||||
return compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-At", "-c", query).strip()
|
||||
|
||||
|
||||
def wait_ready(base_url=BASE_URL, seconds=60):
|
||||
"""Ждёт устойчивой готовности: балансировщик мог ещё не отметить отказ, поэтому одного ответа 200 мало."""
|
||||
deadline = time.monotonic() + seconds
|
||||
stable_since = None
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
ready = call("GET", "/health/ready", base_url=base_url)[0] == 200
|
||||
except OSError:
|
||||
ready = False
|
||||
if not ready:
|
||||
stable_since = None
|
||||
elif stable_since is None:
|
||||
stable_since = time.monotonic()
|
||||
elif time.monotonic() - stable_since >= 3:
|
||||
return
|
||||
time.sleep(0.3)
|
||||
raise AssertionError("стенд не стал готов за %d секунд" % seconds)
|
||||
|
||||
|
||||
def timed(*args, **kwargs):
|
||||
"""Как call, но первым элементом возвращает время ответа в секундах."""
|
||||
started = time.monotonic()
|
||||
result = call(*args, **kwargs)
|
||||
return (time.monotonic() - started, *result)
|
||||
@@ -0,0 +1,91 @@
|
||||
"""Недоступность Redis и PostgreSQL через балансировщик.
|
||||
|
||||
Пока реплики не признаны неготовыми, 503 отвечает API, потом сам балансировщик. Формат ошибки у них один.
|
||||
"""
|
||||
import unittest
|
||||
|
||||
from stand import call, compose, timed, wait_ready
|
||||
from api import basic, history, new_chat, new_key, new_user, send, user_body
|
||||
|
||||
# таймауты в .env.example: 2 с на Redis, 3 с на ожидание соединения с БД; берём запас
|
||||
MAX_SECONDS = 6
|
||||
|
||||
|
||||
class DependencyDownTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
wait_ready()
|
||||
self.user = new_user("dep")
|
||||
self.chat = new_chat(self.user)
|
||||
send(self.user, self.chat, "сообщение до отказа")
|
||||
self.messages = "/api/v1/chats/" + self.chat["id"] + "/messages"
|
||||
|
||||
def assert_unavailable(self, result):
|
||||
elapsed, status, body, headers = result
|
||||
self.assertEqual(status, 503)
|
||||
self.assertEqual(body["error"]["code"], "unavailable")
|
||||
self.assertEqual(body["error"]["request_id"], headers["X-Request-Id"])
|
||||
self.assertLess(elapsed, MAX_SECONDS)
|
||||
|
||||
def test_redis_down(self):
|
||||
compose("stop", "redis")
|
||||
self.addCleanup(wait_ready)
|
||||
self.addCleanup(compose, "start", "redis")
|
||||
|
||||
# сессию проверить нечем: запрос с настоящим токеном не выполняется, но и чужим не становится
|
||||
self.assert_unavailable(timed("GET", "/api/v1/users/me", user=self.user))
|
||||
self.assert_unavailable(timed("GET", self.messages, user=self.user))
|
||||
key = {"Idempotency-Key": new_key()}
|
||||
self.assert_unavailable(timed("POST", self.messages, {"text": "во время отказа"}, user=self.user, headers=key))
|
||||
# поддельный токен тоже не принимается за действующий
|
||||
self.assert_unavailable(timed("GET", "/api/v1/users/me", user={"token": "x" * 43}))
|
||||
# без токена Redis не нужен: API ответит 401, балансировщик без готовых реплик 503, но не данные
|
||||
self.assertIn(call("GET", "/api/v1/users/me")[0], (401, 503))
|
||||
self.assertIn(call("GET", self.messages)[0], (401, 503))
|
||||
# новую сессию создать негде
|
||||
self.assert_unavailable(timed("POST", "/api/v1/auth/sessions",
|
||||
headers=basic(self.user["username"], self.user["password"])))
|
||||
self.assert_unavailable(timed("GET", "/health/ready"))
|
||||
|
||||
compose("start", "redis")
|
||||
wait_ready()
|
||||
# прежний токен снова работает: сессия пережила остановку Redis, а сообщение во время отказа не записалось
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user=self.user)[1], self.user["user"])
|
||||
self.assertEqual([item["text"] for item in history(self.user, self.chat, 50)[0]], ["сообщение до отказа"])
|
||||
|
||||
def test_uncertain_write_can_be_repeated_with_same_key(self):
|
||||
compose("stop", "postgres")
|
||||
self.addCleanup(wait_ready)
|
||||
self.addCleanup(compose, "start", "postgres")
|
||||
key = new_key()
|
||||
self.assertEqual(send(self.user, self.chat, "важное", key=key)[0], 503)
|
||||
compose("start", "postgres")
|
||||
wait_ready()
|
||||
first = send(self.user, self.chat, "важное", key=key)
|
||||
second = send(self.user, self.chat, "важное", key=key)
|
||||
self.assertEqual((first[0], second[0]), (201, 201))
|
||||
self.assertEqual(first[1], second[1])
|
||||
|
||||
def test_postgres_down(self):
|
||||
compose("stop", "postgres")
|
||||
self.addCleanup(wait_ready)
|
||||
self.addCleanup(compose, "start", "postgres")
|
||||
|
||||
self.assert_unavailable(timed("GET", "/api/v1/users/me", user=self.user))
|
||||
self.assert_unavailable(timed("GET", self.messages, user=self.user))
|
||||
key = {"Idempotency-Key": new_key()}
|
||||
self.assert_unavailable(timed("POST", self.messages, {"text": "во время отказа"}, user=self.user, headers=key))
|
||||
self.assert_unavailable(timed("POST", "/api/v1/users", user_body()))
|
||||
self.assert_unavailable(timed("POST", "/api/v1/auth/sessions",
|
||||
headers=basic(self.user["username"], self.user["password"])))
|
||||
self.assertIn(call("GET", "/api/v1/users/me")[0], (401, 503))
|
||||
self.assert_unavailable(timed("GET", "/health/ready"))
|
||||
|
||||
compose("start", "postgres")
|
||||
wait_ready()
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user=self.user)[1], self.user["user"])
|
||||
self.assertEqual([item["text"] for item in history(self.user, self.chat, 50)[0]], ["сообщение до отказа"])
|
||||
self.assertEqual(send(self.user, self.chat, "после восстановления")[0], 201)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,75 @@
|
||||
"""Истечение сессии и ключа. Проверяется на отдельном API с TTL 2 секунды (порт 8081, только compose.test.yaml)."""
|
||||
import datetime
|
||||
import time
|
||||
import unittest
|
||||
|
||||
from stand import call, compose, wait_ready
|
||||
from api import login, new_key, new_user, send
|
||||
|
||||
SHORT_TTL_URL = "http://localhost:8081"
|
||||
|
||||
|
||||
class SessionExpiryTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
compose("up", "-d", "--no-deps", "--no-build", "api-short-ttl")
|
||||
cls.addClassCleanup(compose, "rm", "-sf", "api-short-ttl")
|
||||
wait_ready(SHORT_TTL_URL)
|
||||
|
||||
def test_session_expires(self):
|
||||
user = new_user("ttl", base_url=SHORT_TTL_URL)
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)[0], 200)
|
||||
time.sleep(3)
|
||||
status, body, headers = call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)
|
||||
self.assertEqual(status, 401)
|
||||
self.assertEqual(body["error"]["code"], "unauthorized")
|
||||
self.assertTrue(headers["WWW-Authenticate"].startswith("Bearer "))
|
||||
# logout с истёкшим токеном тоже 401
|
||||
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", user=user, base_url=SHORT_TTL_URL)[0], 401)
|
||||
|
||||
def test_idempotency_key_is_free_after_ttl(self):
|
||||
user = new_user("idem", base_url=SHORT_TTL_URL)
|
||||
chat = new_chat_short(user)
|
||||
key = new_key()
|
||||
first = send(user, chat, "первое", key=key, base_url=SHORT_TTL_URL)
|
||||
repeat = send(user, chat, "первое", key=key, base_url=SHORT_TTL_URL)
|
||||
self.assertEqual((first[0], repeat[1]), (201, first[1]))
|
||||
time.sleep(2.2)
|
||||
# сессия живёт столько же, поэтому нужен новый вход
|
||||
_, session, _ = login(user["username"], user["password"], base_url=SHORT_TTL_URL)
|
||||
again = send({**user, "token": session["token"]}, chat, "уже другое", key=key, base_url=SHORT_TTL_URL)
|
||||
self.assertEqual(again[0], 201)
|
||||
self.assertNotEqual(again[1]["id"], first[1]["id"])
|
||||
|
||||
def test_expires_at_matches_ttl(self):
|
||||
user = new_user("ttl", base_url=SHORT_TTL_URL)
|
||||
_, session, _ = login(user["username"], user["password"], base_url=SHORT_TTL_URL)
|
||||
expires_at = datetime.datetime.fromisoformat(session["expires_at"][:-1] + "+00:00")
|
||||
left = (expires_at - datetime.datetime.now(datetime.timezone.utc)).total_seconds()
|
||||
self.assertTrue(0 < left <= 2.5, left)
|
||||
|
||||
def test_requests_do_not_extend_session(self):
|
||||
user = new_user("ttl", base_url=SHORT_TTL_URL)
|
||||
deadline = time.monotonic() + 3
|
||||
while time.monotonic() < deadline:
|
||||
call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)
|
||||
time.sleep(0.2)
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)[0], 401)
|
||||
|
||||
def test_login_after_expiry(self):
|
||||
user = new_user("ttl", base_url=SHORT_TTL_URL)
|
||||
time.sleep(3)
|
||||
status, session, _ = login(user["username"], user["password"], base_url=SHORT_TTL_URL)
|
||||
self.assertEqual(status, 201)
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user=session, base_url=SHORT_TTL_URL)[0], 200)
|
||||
|
||||
|
||||
def new_chat_short(owner):
|
||||
body = {"title": "Чат", "member_ids": [owner["id"]]}
|
||||
status, chat, _ = call("POST", "/api/v1/chats", body, user=owner, base_url=SHORT_TTL_URL)
|
||||
assert status == 201, status
|
||||
return chat
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,263 @@
|
||||
"""Согласованность S3 и PostgreSQL, отказ S3, приватность bucket. Состояние после сбоя создаётся настоящими сбоями."""
|
||||
import hashlib
|
||||
import socket
|
||||
import subprocess
|
||||
import threading
|
||||
import time
|
||||
import unittest
|
||||
import urllib.parse
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
from stand import BASE_URL, call, compose, sql, timed, wait_ready
|
||||
from api import new_chat, new_user, request_bytes, send
|
||||
from samples import noisy_png
|
||||
|
||||
FIXTURE = (Path(__file__).resolve().parents[2] / "tests/fixtures/sample.png").read_bytes()
|
||||
LIST_OBJECTS = """
|
||||
import config
|
||||
from objects import ObjectStore
|
||||
store = ObjectStore(config.read_secret("S3_JANITOR_ACCESS_KEY_ID"), config.read_secret("S3_JANITOR_SECRET_ACCESS_KEY"))
|
||||
for page in store.pages():
|
||||
for item in page:
|
||||
print(item["Key"])
|
||||
"""
|
||||
PROBE_API_KEY = """
|
||||
import urllib.error, urllib.request
|
||||
import config
|
||||
from botocore.exceptions import ClientError
|
||||
from objects import ObjectStore
|
||||
store = ObjectStore(config.read_secret("S3_ACCESS_KEY_ID"), config.read_secret("S3_SECRET_ACCESS_KEY"))
|
||||
def attempt(name, action):
|
||||
try:
|
||||
action()
|
||||
print(name, "allowed")
|
||||
except ClientError as error:
|
||||
print(name, error.response["Error"]["Code"])
|
||||
attempt("list", lambda: store.client.list_objects_v2(Bucket=store.bucket))
|
||||
attempt("create_bucket", lambda: store.client.create_bucket(Bucket="other"))
|
||||
attempt("delete_bucket", lambda: store.client.delete_bucket(Bucket=store.bucket))
|
||||
try:
|
||||
urllib.request.urlopen(config.S3_ENDPOINT + "/" + store.bucket + "/KEY", timeout=3)
|
||||
print("anonymous allowed")
|
||||
except urllib.error.HTTPError as error:
|
||||
print("anonymous", error.code)
|
||||
"""
|
||||
|
||||
|
||||
def upload(user, chat, data=FIXTURE):
|
||||
path = "/api/v1/chats/%s/attachments?filename=a.png" % chat["id"]
|
||||
return call("POST", path, raw=data, user=user, headers={"Content-Type": "image/png"}, timeout=30)
|
||||
|
||||
|
||||
def bucket_keys():
|
||||
return set(compose("exec", "-T", "janitor", "python", "-c", LIST_OBJECTS).split())
|
||||
|
||||
|
||||
def janitor(*args):
|
||||
# логи идут в stdout контейнера; сервисный проход на проверки не влияет: его период 300 секунд
|
||||
return compose("run", "--rm", "--no-deps", "janitor", "python", "janitor.py", "--once", *args)
|
||||
|
||||
|
||||
def in_api_replica(*command):
|
||||
# по id контейнера: после поочерёдной замены номера реплик уже не 1 и 2
|
||||
container = compose("ps", "-q", "api").split()[0]
|
||||
return subprocess.run(["docker", "exec", container, *command], check=True, capture_output=True, text=True).stdout
|
||||
|
||||
|
||||
def wait_s3(seconds=90):
|
||||
"""S3 готов, когда контейнер healthy: том данных зарегистрирован, запросы к объектам не зависают."""
|
||||
deadline = time.monotonic() + seconds
|
||||
while compose("ps", "--format", "{{.Health}}", "s3").strip() != "healthy":
|
||||
if time.monotonic() > deadline:
|
||||
raise AssertionError("S3 не стал готов за %d секунд" % seconds)
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
def rows(condition="true"):
|
||||
output = sql("SELECT object_key FROM attachments WHERE " + condition)
|
||||
return set(output.split())
|
||||
|
||||
|
||||
class StorageBase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
wait_ready()
|
||||
self.user = new_user("files")
|
||||
self.chat = new_chat(self.user)
|
||||
|
||||
def tearDown(self):
|
||||
# следы теста не должны влиять на сверку в следующем; S3 к этому моменту может ещё запускаться
|
||||
compose("start", "s3")
|
||||
wait_s3()
|
||||
janitor("--grace-seconds", "0")
|
||||
|
||||
|
||||
class ConsistencyTest(StorageBase):
|
||||
def test_commit_lost_after_s3_put(self):
|
||||
"""Состояние как после падения между PUT и подтверждением: объект есть, строка pending, клиент не получил 201."""
|
||||
attachment = upload(self.user, self.chat)[1]
|
||||
key = "originals/" + attachment["id"]
|
||||
self.assertIn(key, bucket_keys())
|
||||
sql("UPDATE attachments SET state = 'pending', created_at = now() - interval '2 hours' WHERE id = '%s'" % attachment["id"])
|
||||
|
||||
janitor()
|
||||
|
||||
self.assertNotIn(key, bucket_keys())
|
||||
self.assertEqual(rows("id = '%s'" % attachment["id"]), set())
|
||||
|
||||
def test_grace_period_protects_fresh_upload(self):
|
||||
attachment = upload(self.user, self.chat)[1]
|
||||
key = "originals/" + attachment["id"]
|
||||
sql("UPDATE attachments SET state = 'pending' WHERE id = '%s'" % attachment["id"])
|
||||
|
||||
janitor() # строка свежая, загрузка могла ещё идти
|
||||
|
||||
self.assertIn(key, bucket_keys())
|
||||
self.assertEqual(rows("id = '%s'" % attachment["id"]), {key})
|
||||
# строку не видно снаружи, пока она pending
|
||||
self.assertEqual(call("GET", "/api/v1/attachments/" + attachment["id"], user=self.user)[0], 404)
|
||||
|
||||
def test_ready_attachments_are_never_removed(self):
|
||||
attachment = upload(self.user, self.chat)[1]
|
||||
janitor("--grace-seconds", "0")
|
||||
status, body, _ = request_bytes("GET", "/api/v1/attachments/%s/content" % attachment["id"], user=self.user)
|
||||
self.assertEqual((status, body), (200, FIXTURE))
|
||||
|
||||
def test_orphan_object_is_removed_only_after_grace(self):
|
||||
attachment = upload(self.user, self.chat)[1]
|
||||
key = "originals/" + attachment["id"]
|
||||
sql("DELETE FROM attachments WHERE id = '%s'" % attachment["id"])
|
||||
|
||||
janitor()
|
||||
self.assertIn(key, bucket_keys())
|
||||
|
||||
janitor("--grace-seconds", "0", "--dry-run")
|
||||
self.assertIn(key, bucket_keys())
|
||||
|
||||
janitor("--grace-seconds", "0")
|
||||
self.assertNotIn(key, bucket_keys())
|
||||
|
||||
def test_second_pass_changes_nothing(self):
|
||||
attachment = upload(self.user, self.chat)[1]
|
||||
sql("UPDATE attachments SET state = 'pending', created_at = now() - interval '2 hours' WHERE id = '%s'" % attachment["id"])
|
||||
janitor()
|
||||
before = bucket_keys(), rows()
|
||||
janitor()
|
||||
self.assertEqual((bucket_keys(), rows()), before)
|
||||
|
||||
def test_interrupted_upload_leaves_nothing(self):
|
||||
before = bucket_keys(), rows()
|
||||
address = urllib.parse.urlsplit(BASE_URL)
|
||||
path = "/api/v1/chats/%s/attachments?filename=a.png" % self.chat["id"]
|
||||
head = ("POST %s HTTP/1.1\r\nHost: x\r\nContent-Type: image/png\r\nContent-Length: 5000000\r\n"
|
||||
"Authorization: Bearer %s\r\n\r\n" % (path, self.user["token"])).encode()
|
||||
for _ in range(4):
|
||||
with socket.create_connection((address.hostname, address.port), timeout=5) as connection:
|
||||
connection.sendall(head + b"\x89PNG" + b"x" * 200000)
|
||||
time.sleep(0.2)
|
||||
time.sleep(1)
|
||||
self.assertEqual((bucket_keys(), rows()), before)
|
||||
|
||||
def test_postgres_lost_during_parallel_uploads(self):
|
||||
"""Настоящий сбой: база пропадает, пока идут загрузки. Часть объектов попадает в S3 без подтверждения."""
|
||||
data = noisy_png(3 * 1024 * 1024)
|
||||
# подтверждённые до сбоя файлы: они обязаны уцелеть при любом исходе гонки ниже
|
||||
confirmed_before = [upload(self.user, self.chat, data)[1] for _ in range(3)]
|
||||
before_keys = bucket_keys()
|
||||
barrier = threading.Barrier(13)
|
||||
|
||||
def post(_):
|
||||
barrier.wait()
|
||||
confirmed = []
|
||||
for _ in range(6):
|
||||
try:
|
||||
status, attachment, _ = upload(self.user, self.chat, data)
|
||||
except OSError:
|
||||
continue
|
||||
if status == 201:
|
||||
confirmed.append(attachment)
|
||||
return confirmed
|
||||
|
||||
with ThreadPoolExecutor(max_workers=12) as pool:
|
||||
jobs = [pool.submit(post, number) for number in range(12)]
|
||||
barrier.wait()
|
||||
time.sleep(0.25)
|
||||
compose("kill", "postgres")
|
||||
confirmed = confirmed_before + [item for job in jobs for item in job.result()]
|
||||
compose("start", "postgres")
|
||||
self.addCleanup(wait_ready)
|
||||
wait_ready()
|
||||
|
||||
leftovers = bucket_keys() - before_keys - {"originals/" + item["id"] for item in confirmed}
|
||||
janitor("--grace-seconds", "0")
|
||||
|
||||
self.assertEqual(rows("state = 'pending'"), set())
|
||||
self.assertEqual(bucket_keys(), rows("state = 'ready'"))
|
||||
self.assertGreaterEqual(len(confirmed), 3)
|
||||
for attachment in confirmed:
|
||||
status, body, _ = request_bytes("GET", "/api/v1/attachments/%s/content" % attachment["id"], user=self.user)
|
||||
self.assertEqual((status, hashlib.sha256(body).hexdigest()), (200, attachment["sha256"]))
|
||||
print("\nподтверждено %d, в S3 без подтверждения %d, после очистки расхождений нет" % (len(confirmed), len(leftovers)))
|
||||
|
||||
|
||||
class S3DownTest(StorageBase):
|
||||
def test_s3_down(self):
|
||||
attachment = upload(self.user, self.chat)[1]
|
||||
compose("stop", "s3")
|
||||
self.addCleanup(wait_ready)
|
||||
self.addCleanup(compose, "start", "s3")
|
||||
|
||||
path = "/api/v1/chats/%s/attachments?filename=a.png" % self.chat["id"]
|
||||
elapsed, status, body, headers = timed("POST", path, raw=FIXTURE, user=self.user, headers={"Content-Type": "image/png"})
|
||||
self.assertEqual((status, body["error"]["code"]), (503, "unavailable"))
|
||||
self.assertEqual(body["error"]["request_id"], headers["X-Request-Id"])
|
||||
self.assertLess(elapsed, 10)
|
||||
self.assertEqual(request_bytes("GET", "/api/v1/attachments/%s/content" % attachment["id"], user=self.user)[0], 503)
|
||||
|
||||
# без S3 мессенджер продолжает работать: текст, метаданные и готовность реплик от него не зависят
|
||||
self.assertEqual(send(self.user, self.chat, "текст без S3")[0], 201)
|
||||
self.assertEqual(call("GET", "/api/v1/attachments/" + attachment["id"], user=self.user)[0], 200)
|
||||
self.assertEqual(call("GET", "/health/ready")[0], 200)
|
||||
|
||||
compose("start", "s3")
|
||||
wait_s3()
|
||||
status, body, _ = request_bytes("GET", "/api/v1/attachments/%s/content" % attachment["id"], user=self.user)
|
||||
self.assertEqual((status, body), (200, FIXTURE))
|
||||
|
||||
def test_failed_upload_is_cleaned(self):
|
||||
compose("stop", "s3")
|
||||
self.addCleanup(wait_ready)
|
||||
self.addCleanup(compose, "start", "s3")
|
||||
self.assertEqual(upload(self.user, self.chat)[0], 503)
|
||||
self.assertTrue(rows("state = 'pending'")) # строка осталась, клиент получил ошибку
|
||||
compose("start", "s3")
|
||||
wait_s3()
|
||||
janitor("--grace-seconds", "0")
|
||||
self.assertEqual(rows("state = 'pending'"), set())
|
||||
|
||||
|
||||
class PrivateBucketTest(StorageBase):
|
||||
def test_bucket_is_private_and_api_key_is_limited(self):
|
||||
attachment = upload(self.user, self.chat)[1]
|
||||
script = PROBE_API_KEY.replace("/KEY", "/originals/" + attachment["id"])
|
||||
output = in_api_replica("python", "-c", script)
|
||||
self.assertIn("list AccessDenied", output)
|
||||
self.assertIn("create_bucket AccessDenied", output)
|
||||
self.assertIn("delete_bucket AccessDenied", output)
|
||||
self.assertIn("anonymous 403", output)
|
||||
|
||||
def test_bucket_bootstrap_can_be_repeated(self):
|
||||
before = bucket_keys()
|
||||
output = compose("run", "--rm", "--no-deps", "s3-init")
|
||||
self.assertIn("bucket уже есть", output)
|
||||
self.assertIn("пробная запись прошла", output)
|
||||
self.assertEqual(bucket_keys(), before)
|
||||
|
||||
def test_no_file_on_api_replica(self):
|
||||
attachment = upload(self.user, self.chat)[1]
|
||||
output = in_api_replica("sh", "-c", "find / -xdev -name '*%s*' 2>/dev/null | wc -l" % attachment["id"])
|
||||
self.assertEqual(output.split()[-1], "0")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,90 @@
|
||||
"""Проверки на уровне БД: откат составной операции, гонка регистрации, повторный запуск миграций."""
|
||||
import threading
|
||||
import unittest
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
from stand import call, compose, sql, wait_ready
|
||||
from api import new_chat, new_key, new_user, send, user_body
|
||||
|
||||
|
||||
class TransactionTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
wait_ready()
|
||||
cls.alice, cls.bob = new_user("alice"), new_user("bob")
|
||||
|
||||
def create_chat(self, title, member_ids):
|
||||
return call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=self.alice)
|
||||
|
||||
def test_chat_with_unknown_member_is_rolled_back(self):
|
||||
title = "rollback-" + uuid.uuid4().hex
|
||||
# Алиса и Боб существуют, третьего участника нет: вставка чата и двух участников уже выполнена,
|
||||
# на третьем срабатывает внешний ключ, и транзакция должна откатить всё
|
||||
status, body, _ = self.create_chat(title, [self.alice["id"], self.bob["id"], str(uuid.uuid4())])
|
||||
self.assertEqual(status, 400)
|
||||
self.assertEqual(body["error"]["code"], "invalid_request")
|
||||
self.assertEqual(sql("SELECT count(*) FROM chats WHERE title = '%s'" % title), "0")
|
||||
self.assertEqual(sql("SELECT count(*) FROM chat_members m LEFT JOIN chats c ON c.id = m.chat_id WHERE c.id IS NULL"), "0")
|
||||
|
||||
def test_valid_chat_is_committed_whole(self):
|
||||
title = "commit-" + uuid.uuid4().hex
|
||||
status, chat, _ = self.create_chat(title, [self.alice["id"], self.bob["id"]])
|
||||
self.assertEqual(status, 201)
|
||||
self.assertEqual(sql("SELECT count(*) FROM chats WHERE title = '%s'" % title), "1")
|
||||
self.assertEqual(sql("SELECT count(*) FROM chat_members WHERE chat_id = '%s'" % chat["id"]), "2")
|
||||
|
||||
def test_username_race_creates_one_row(self):
|
||||
body = user_body(username="race_" + uuid.uuid4().hex[:8])
|
||||
barrier = threading.Barrier(10)
|
||||
|
||||
def register(_):
|
||||
barrier.wait()
|
||||
return call("POST", "/api/v1/users", body)[0]
|
||||
|
||||
with ThreadPoolExecutor(max_workers=10) as pool:
|
||||
statuses = sorted(pool.map(register, range(10)))
|
||||
self.assertEqual(statuses, [201] + [409] * 9)
|
||||
self.assertEqual(sql("SELECT count(*) FROM users WHERE username = '%s'" % body["username"]), "1")
|
||||
|
||||
def test_same_key_in_parallel_creates_one_row(self):
|
||||
chat = new_chat(self.alice)
|
||||
key = new_key()
|
||||
barrier = threading.Barrier(20)
|
||||
|
||||
def post(_):
|
||||
barrier.wait()
|
||||
return send(self.alice, chat, "один раз", key=key)
|
||||
|
||||
with ThreadPoolExecutor(max_workers=20) as pool:
|
||||
results = list(pool.map(post, range(20)))
|
||||
self.assertEqual({status for status, _, _ in results}, {201})
|
||||
self.assertEqual(len({message["id"] for _, message, _ in results}), 1)
|
||||
self.assertEqual(sql("SELECT count(*) FROM messages WHERE chat_id = '%s'" % chat["id"]), "1")
|
||||
self.assertEqual(sql("SELECT count(*) FROM idempotency_keys WHERE chat_id = '%s'" % chat["id"]), "1")
|
||||
|
||||
def test_failed_message_leaves_no_key(self):
|
||||
# чужой чат: сообщение не создано, и ключ тоже не занят
|
||||
eve = new_user("eve")
|
||||
chat = new_chat(self.alice)
|
||||
key = new_key()
|
||||
self.assertEqual(send(eve, chat, "чужое", key=key)[0], 404)
|
||||
self.assertEqual(sql("SELECT count(*) FROM idempotency_keys WHERE chat_id = '%s'" % chat["id"]), "0")
|
||||
|
||||
def test_password_is_stored_as_argon2id_hash(self):
|
||||
stored = sql("SELECT password_hash FROM users WHERE id = '%s'" % self.alice["id"])
|
||||
self.assertTrue(stored.startswith("$argon2id$"), stored[:12])
|
||||
self.assertNotIn(self.alice["password"], stored)
|
||||
|
||||
def test_migrations_can_be_repeated(self):
|
||||
before = sql("SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM chats), (SELECT count(*) FROM messages)")
|
||||
output = compose("run", "--rm", "migrate")
|
||||
self.assertIn("уже применена: 0001_init.sql", output)
|
||||
self.assertIn("уже применена: 0003_attachments.sql", output)
|
||||
self.assertEqual(sql("SELECT count(*) FROM schema_migrations"), "3")
|
||||
after = sql("SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM chats), (SELECT count(*) FROM messages)")
|
||||
self.assertEqual(before, after)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,177 @@
|
||||
"""Сверка с настоящим декодером. Pillow здесь судья: загружает изображение полностью и без уменьшения.
|
||||
|
||||
Главное правило: файл, который Pillow отвергает, отвергаем и мы. Обратное тоже проверяется на настоящих
|
||||
файлах: всё, что Pillow умеет записать, должно приниматься.
|
||||
"""
|
||||
import io
|
||||
import random
|
||||
import struct
|
||||
import sys
|
||||
import unittest
|
||||
import warnings
|
||||
import zlib
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path[:0] = [str(ROOT / "src"), str(ROOT / "student-tests")]
|
||||
from PIL import Image, ImageFile # noqa: E402
|
||||
|
||||
import images # noqa: E402
|
||||
from samples import REAL_IMAGES, make_png, png_chunk # noqa: E402
|
||||
|
||||
LIMIT = 40_000_000
|
||||
ImageFile.LOAD_TRUNCATED_IMAGES = False
|
||||
warnings.simplefilter("ignore")
|
||||
|
||||
|
||||
def pillow_accepts(data):
|
||||
try:
|
||||
with Image.open(io.BytesIO(data), formats=["PNG", "JPEG"]) as image:
|
||||
image.load()
|
||||
with Image.open(io.BytesIO(data), formats=["PNG", "JPEG"]) as image:
|
||||
image.verify()
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def we_accept(data):
|
||||
try:
|
||||
images.inspect(io.BytesIO(data), LIMIT)
|
||||
return True
|
||||
except (images.NotAnImage, images.TooManyPixels):
|
||||
return False
|
||||
|
||||
|
||||
def picture(mode, size=(64, 48)):
|
||||
image = Image.effect_noise(size, 60).convert("RGB")
|
||||
return image.convert(mode) if mode != "RGB" else image
|
||||
|
||||
|
||||
def encoded(image, **options):
|
||||
out = io.BytesIO()
|
||||
image.save(out, **options)
|
||||
return out.getvalue()
|
||||
|
||||
|
||||
def valid_corpus():
|
||||
corpus = {}
|
||||
for mode in ("1", "L", "LA", "P", "PA", "RGB", "RGBA", "I;16"):
|
||||
try:
|
||||
corpus["png-" + mode] = encoded(picture(mode), format="PNG")
|
||||
except (OSError, ValueError):
|
||||
pass
|
||||
corpus["png-optimized"] = encoded(picture("RGB"), format="PNG", optimize=True)
|
||||
corpus["png-1x1"] = encoded(picture("RGB", (1, 1)), format="PNG")
|
||||
corpus["png-text"] = encoded(picture("L"), format="PNG", dpi=(72, 72))
|
||||
for mode in ("L", "RGB", "CMYK"):
|
||||
corpus["jpeg-" + mode] = encoded(picture(mode), format="JPEG")
|
||||
for subsampling in (0, 1, 2):
|
||||
corpus["jpeg-sub-%d" % subsampling] = encoded(picture("RGB"), format="JPEG", subsampling=subsampling)
|
||||
corpus["jpeg-progressive"] = encoded(picture("RGB"), format="JPEG", progressive=True)
|
||||
corpus["jpeg-optimized"] = encoded(picture("RGB"), format="JPEG", optimize=True)
|
||||
corpus["jpeg-restart"] = encoded(picture("RGB"), format="JPEG", restart_marker_blocks=4)
|
||||
corpus["jpeg-1x1"] = encoded(picture("RGB", (1, 1)), format="JPEG")
|
||||
corpus["jpeg-flat"] = encoded(Image.new("L", (512, 512), 128), format="JPEG")
|
||||
corpus["jpeg-flat-progressive"] = encoded(Image.new("RGB", (512, 512), (9, 9, 9)), format="JPEG", progressive=True)
|
||||
corpus["jpeg-exif"] = encoded(picture("RGB"), format="JPEG", exif=b"Exif\x00\x00MM\x00*\x00\x00\x00\x08\x00\x00")
|
||||
corpus.update({name: data for name, (_, data) in REAL_IMAGES.items()})
|
||||
return corpus
|
||||
|
||||
|
||||
class ValidFilesTest(unittest.TestCase):
|
||||
def test_every_valid_file_is_accepted(self):
|
||||
for name, data in valid_corpus().items():
|
||||
with self.subTest(name):
|
||||
self.assertTrue(pillow_accepts(data), "образец сам не принят Pillow")
|
||||
self.assertTrue(we_accept(data))
|
||||
|
||||
|
||||
class AgreementTest(unittest.TestCase):
|
||||
def assert_no_false_accept(self, name, candidates):
|
||||
false_accepts = []
|
||||
rejected = accepted = 0
|
||||
for data in candidates:
|
||||
ours = we_accept(data)
|
||||
theirs = pillow_accepts(data)
|
||||
accepted += ours
|
||||
rejected += not ours
|
||||
if ours and not theirs:
|
||||
false_accepts.append(data)
|
||||
print("%s: принято %d, отвергнуто %d, принято вопреки Pillow %d" % (name, accepted, rejected, len(false_accepts)))
|
||||
self.assertEqual(false_accepts[:1], [], "%s: принято %d файлов, которые Pillow отвергает" % (name, len(false_accepts)))
|
||||
|
||||
def test_random_bytes_changed(self):
|
||||
rng = random.Random(20261031)
|
||||
corpus = valid_corpus()
|
||||
|
||||
def mutated():
|
||||
for name, original in corpus.items():
|
||||
for _ in range(200):
|
||||
data = bytearray(original)
|
||||
for _ in range(rng.randint(1, 6)):
|
||||
data[rng.randrange(len(data))] = rng.randrange(256)
|
||||
yield bytes(data)
|
||||
|
||||
self.assert_no_false_accept("замена байтов", mutated())
|
||||
|
||||
def test_cut_files(self):
|
||||
rng = random.Random(1031)
|
||||
corpus = valid_corpus()
|
||||
|
||||
def cut():
|
||||
for original in corpus.values():
|
||||
for _ in range(40):
|
||||
end = rng.randrange(len(original))
|
||||
yield original[:end]
|
||||
yield original[:end] + b"\xff\xd9"
|
||||
|
||||
self.assert_no_false_accept("обрезка", cut())
|
||||
|
||||
def test_png_with_recomputed_crc(self):
|
||||
"""Самый важный случай: заголовок и CRC верны, испорчено только содержимое. Именно такой файл и был в замечании."""
|
||||
rng = random.Random(7)
|
||||
|
||||
def forged():
|
||||
for _ in range(1500):
|
||||
width, height = rng.randint(1, 12), rng.randint(1, 12)
|
||||
size = (1 + width * 3) * height
|
||||
raw = bytearray(rng.choice(b"\x00\x01\x02\x03\x04") for _ in range(size))
|
||||
for _ in range(rng.randint(0, 3)):
|
||||
raw[rng.randrange(size)] = rng.randrange(256)
|
||||
yield make_png(width, height, bytes(raw))
|
||||
|
||||
self.assert_no_false_accept("PNG с верными CRC", forged())
|
||||
|
||||
def test_jpeg_with_headers_rebuilt(self):
|
||||
rng = random.Random(9)
|
||||
original = REAL_IMAGES["jpeg_baseline"][1]
|
||||
scan = original.index(b"\xff\xda")
|
||||
length = struct.unpack(">H", original[scan + 2:scan + 4])[0]
|
||||
head = original[:scan + 2 + length]
|
||||
|
||||
def forged():
|
||||
for _ in range(800):
|
||||
body = bytes(rng.randrange(255) for _ in range(rng.randint(0, 300)))
|
||||
yield head + body.replace(b"\xff", b"\x00") + b"\xff\xd9"
|
||||
|
||||
self.assert_no_false_accept("JPEG с настоящими заголовками", forged())
|
||||
|
||||
def test_png_chunks_shuffled(self):
|
||||
rng = random.Random(3)
|
||||
signature = b"\x89PNG\r\n\x1a\n"
|
||||
chunks = [b"IHDR", b"PLTE", b"IDAT", b"IEND", b"tEXt"]
|
||||
|
||||
def forged():
|
||||
header = struct.pack(">IIBBBBB", 2, 2, 8, 3, 0, 0, 0)
|
||||
bodies = {b"IHDR": header, b"PLTE": b"\x01\x02\x03", b"IDAT": zlib.compress(b"\x00\x00\x00" * 2),
|
||||
b"IEND": b"", b"tEXt": b"a\x00b"}
|
||||
for _ in range(600):
|
||||
order = rng.choices(chunks, k=rng.randint(1, 6))
|
||||
yield signature + b"".join(png_chunk(kind, bodies[kind]) for kind in order)
|
||||
|
||||
self.assert_no_false_accept("порядок блоков PNG", forged())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,288 @@
|
||||
"""Разбор изображений без сервера. Запускается внутри образа API (make test-images): нужен Pillow."""
|
||||
import io
|
||||
import random
|
||||
import struct
|
||||
import sys
|
||||
import unittest
|
||||
import zlib
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path[:0] = [str(ROOT / "src"), str(ROOT / "student-tests")]
|
||||
import images # noqa: E402
|
||||
from samples import REAL_IMAGES, make_png, png_chunk # noqa: E402
|
||||
|
||||
LIMIT = 40_000_000
|
||||
|
||||
|
||||
def inspect(data, limit=LIMIT):
|
||||
return images.inspect(io.BytesIO(data), limit)
|
||||
|
||||
|
||||
class RealImagesTest(unittest.TestCase):
|
||||
def test_real_images_are_accepted(self):
|
||||
for name, (content_type, data) in REAL_IMAGES.items():
|
||||
with self.subTest(name):
|
||||
self.assertEqual(inspect(data), content_type)
|
||||
|
||||
def test_course_fixture(self):
|
||||
path = ROOT / "tests/fixtures/sample.png"
|
||||
self.assertEqual(inspect(path.read_bytes()), "image/png")
|
||||
|
||||
def test_jpeg_with_data_after_end(self):
|
||||
# камеры дописывают после конца изображения превью
|
||||
self.assertEqual(inspect(REAL_IMAGES["jpeg_baseline"][1] + b"\xff\xd8" + b"x" * 50), "image/jpeg")
|
||||
|
||||
def test_marker_on_block_border(self):
|
||||
data = bytearray(REAL_IMAGES["jpeg_baseline"][1])
|
||||
start = data.index(b"\xff\xda")
|
||||
length = struct.unpack(">H", data[start + 2:start + 4])[0]
|
||||
padded = data[:start + 2 + length] + b"\x12" * (images.BLOCK - 3) + b"\xff\x00" * 40 + data[start + 2 + length:]
|
||||
self.assertEqual(inspect(bytes(padded)), "image/jpeg")
|
||||
|
||||
|
||||
class BrokenImagesTest(unittest.TestCase):
|
||||
def assert_not_image(self, data):
|
||||
with self.assertRaises(images.NotAnImage):
|
||||
inspect(data)
|
||||
|
||||
def test_truncated(self):
|
||||
for name, (_, data) in REAL_IMAGES.items():
|
||||
for size in (0, 1, 2, 3, 8, 12, len(data) // 2, len(data) - 1):
|
||||
with self.subTest(name=name, size=size):
|
||||
self.assert_not_image(data[:size])
|
||||
|
||||
def test_not_images(self):
|
||||
for data in (b"", b"GIF89a" + b"\x00" * 20, b"%PDF-1.7", b"<svg></svg>", b"\xff\xd8", b"\x89PNG\r\n\x1a\n"):
|
||||
with self.subTest(start=data[:8]):
|
||||
self.assert_not_image(data)
|
||||
|
||||
def test_png_bad_crc(self):
|
||||
data = bytearray(make_png(8, 8))
|
||||
data[-20] ^= 0xFF
|
||||
self.assert_not_image(bytes(data))
|
||||
|
||||
def test_png_data_after_end(self):
|
||||
self.assert_not_image(make_png(8, 8) + b"<script>")
|
||||
|
||||
def test_png_with_wrong_amount_of_pixels(self):
|
||||
self.assert_not_image(make_png(8, 8, b"\x00" * 10))
|
||||
self.assert_not_image(make_png(8, 8, b"\x00" * 10000))
|
||||
|
||||
def test_png_data_is_not_zlib(self):
|
||||
header = struct.pack(">IIBBBBB", 8, 8, 8, 2, 0, 0, 0)
|
||||
data = b"\x89PNG\r\n\x1a\n" + png_chunk(b"IHDR", header) + png_chunk(b"IDAT", b"not zlib") + png_chunk(b"IEND", b"")
|
||||
self.assert_not_image(data)
|
||||
|
||||
def test_png_zero_size(self):
|
||||
self.assert_not_image(make_png(0, 8, b""))
|
||||
|
||||
def test_jpeg_without_frame_or_scan(self):
|
||||
self.assert_not_image(b"\xff\xd8\xff\xd9")
|
||||
self.assert_not_image(b"\xff\xd8\xff\xe0\x00\x04ab\xff\xd9")
|
||||
|
||||
def test_png_data_after_compressed_stream_in_zero_size(self):
|
||||
self.assert_not_image(make_png(1, 0, b""))
|
||||
|
||||
def test_random_corruption_never_crashes(self):
|
||||
random.seed(20261030)
|
||||
for name, (_, original) in REAL_IMAGES.items():
|
||||
for _ in range(300):
|
||||
data = bytearray(original)
|
||||
for _ in range(random.randint(1, 8)):
|
||||
data[random.randrange(len(data))] = random.randrange(256)
|
||||
try:
|
||||
inspect(bytes(data))
|
||||
except (images.NotAnImage, images.TooManyPixels):
|
||||
pass
|
||||
|
||||
|
||||
class ReviewCasesTest(unittest.TestCase):
|
||||
"""Файлы из замечания: заголовки верны, а изображения в них нет."""
|
||||
|
||||
def test_png_with_invalid_filter_byte(self):
|
||||
with self.assertRaises(images.NotAnImage):
|
||||
inspect(make_png(1, 1, b"\xff\x00\x00\x00"))
|
||||
|
||||
def test_jpeg_without_image_data(self):
|
||||
data = bytes.fromhex("ffd8ffc0000b080001000101011100ffda0008010100003f00ffd9")
|
||||
self.assertEqual(len(data), 27)
|
||||
with self.assertRaises(images.NotAnImage):
|
||||
inspect(data)
|
||||
|
||||
|
||||
class PngContentTest(unittest.TestCase):
|
||||
def assert_not_image(self, data):
|
||||
with self.assertRaises(images.NotAnImage):
|
||||
inspect(data)
|
||||
|
||||
def test_bad_filter_in_any_row(self):
|
||||
row = b"\x00" + b"\x07" * 12
|
||||
for bad_row in (0, 1, 7, 15):
|
||||
rows = [row] * 16
|
||||
rows[bad_row] = b"\x05" + b"\x07" * 12
|
||||
with self.subTest(row=bad_row):
|
||||
self.assert_not_image(make_png(4, 16, b"".join(rows)))
|
||||
|
||||
def test_all_valid_filters(self):
|
||||
raw = b"".join(bytes([number % 5]) + b"\x07" * 12 for number in range(16))
|
||||
self.assertEqual(inspect(make_png(4, 16, raw)), "image/png")
|
||||
|
||||
def test_filter_check_crosses_inflate_blocks(self):
|
||||
# строки длиннее блока распаковки: байт фильтра может оказаться в любом месте блока
|
||||
row_size = 1 + 3 * 40000
|
||||
raw = bytearray(b"\x00" * row_size * 5)
|
||||
raw[row_size * 3] = 9
|
||||
self.assert_not_image(make_png(40000, 5, bytes(raw)))
|
||||
raw[row_size * 3] = 4
|
||||
self.assertEqual(inspect(make_png(40000, 5, bytes(raw))), "image/png")
|
||||
|
||||
def test_many_short_rows_are_checked_quickly(self):
|
||||
import time
|
||||
|
||||
height = 5_000_000
|
||||
started = time.monotonic()
|
||||
header = struct.pack(">IIBBBBB", 1, height, 1, 0, 0, 0, 0)
|
||||
data = b"\x89PNG\r\n\x1a\n" + png_chunk(b"IHDR", header)
|
||||
data += png_chunk(b"IDAT", zlib.compress(b"\x00\x80" * height)) + png_chunk(b"IEND", b"")
|
||||
self.assertEqual(inspect(data), "image/png")
|
||||
self.assertLess(time.monotonic() - started, 5)
|
||||
|
||||
def test_interlaced(self):
|
||||
def adam7(width, height, filter_byte=0):
|
||||
rows = images.png_passes(width, height, 24, True)
|
||||
return b"".join((bytes([filter_byte]) + b"\x07" * (size - 1)) * count for size, count in rows)
|
||||
|
||||
def interlaced_png(width, height, raw):
|
||||
header = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 1)
|
||||
return (b"\x89PNG\r\n\x1a\n" + png_chunk(b"IHDR", header) + png_chunk(b"IDAT", zlib.compress(raw))
|
||||
+ png_chunk(b"IEND", b""))
|
||||
|
||||
for width, height in ((1, 1), (2, 3), (5, 5), (8, 8), (33, 17)):
|
||||
with self.subTest(size=(width, height)):
|
||||
self.assertEqual(inspect(interlaced_png(width, height, adam7(width, height))), "image/png")
|
||||
self.assert_not_image(interlaced_png(width, height, adam7(width, height, 7)))
|
||||
self.assert_not_image(interlaced_png(width, height, adam7(width, height) + b"\x00"))
|
||||
self.assert_not_image(interlaced_png(width, height, adam7(width, height)[:-1]))
|
||||
|
||||
def test_chunk_order(self):
|
||||
signature, rest = b"\x89PNG\r\n\x1a\n", make_png(4, 4)[8:]
|
||||
ihdr, tail = rest[:25], rest[25:]
|
||||
end = tail[-12:]
|
||||
idat = tail[:-12]
|
||||
half = len(idat)
|
||||
comment = png_chunk(b"tEXt", b"a\x00b")
|
||||
self.assertEqual(inspect(signature + ihdr + comment + idat + comment + end), "image/png")
|
||||
# два IDAT с другим блоком между ними
|
||||
raw = zlib.compress(b"\x00" * 13 * 4)
|
||||
split = png_chunk(b"IDAT", raw[:5]) + comment + png_chunk(b"IDAT", raw[5:])
|
||||
self.assert_not_image(signature + ihdr + split + end)
|
||||
# неизвестный обязательный блок, неизвестный необязательный, второй IHDR, данные в IEND
|
||||
self.assert_not_image(signature + ihdr + png_chunk(b"XXXX", b"") + idat + end)
|
||||
self.assertEqual(inspect(signature + ihdr + png_chunk(b"xxXx", b"") + idat + end), "image/png")
|
||||
self.assert_not_image(signature + ihdr + ihdr + idat + end)
|
||||
self.assert_not_image(signature + ihdr + idat + png_chunk(b"IEND", b"x"))
|
||||
self.assertGreater(half, 0)
|
||||
|
||||
def test_palette_rules(self):
|
||||
header = struct.pack(">IIBBBBB", 1, 1, 8, 3, 0, 0, 0)
|
||||
idat = png_chunk(b"IDAT", zlib.compress(b"\x00\x00"))
|
||||
start = b"\x89PNG\r\n\x1a\n" + png_chunk(b"IHDR", header)
|
||||
end = png_chunk(b"IEND", b"")
|
||||
self.assertEqual(inspect(start + png_chunk(b"PLTE", b"\x01\x02\x03") + idat + end), "image/png")
|
||||
self.assert_not_image(start + idat + end)
|
||||
self.assert_not_image(start + idat + png_chunk(b"PLTE", b"\x01\x02\x03") + end)
|
||||
self.assert_not_image(start + png_chunk(b"PLTE", b"\x01\x02") + idat + end)
|
||||
|
||||
def test_garbage_after_compressed_data(self):
|
||||
raw = zlib.compress(b"\x00" * 13 * 4) + b"junk"
|
||||
header = struct.pack(">IIBBBBB", 4, 4, 8, 2, 0, 0, 0)
|
||||
data = b"\x89PNG\r\n\x1a\n" + png_chunk(b"IHDR", header) + png_chunk(b"IDAT", raw) + png_chunk(b"IEND", b"")
|
||||
self.assert_not_image(data)
|
||||
|
||||
|
||||
class JpegContentTest(unittest.TestCase):
|
||||
def assert_not_image(self, data):
|
||||
with self.assertRaises(images.NotAnImage):
|
||||
inspect(data)
|
||||
|
||||
def segment(self, data, marker):
|
||||
start = data.index(bytes([0xFF, marker]))
|
||||
return start, 2 + struct.unpack(">H", data[start + 2:start + 4])[0]
|
||||
|
||||
def without_segments(self, data, marker):
|
||||
stripped = bytearray(data)
|
||||
while True:
|
||||
try:
|
||||
start, length = self.segment(bytes(stripped), marker)
|
||||
except ValueError:
|
||||
return bytes(stripped)
|
||||
del stripped[start:start + length]
|
||||
|
||||
def test_without_quantization_tables(self):
|
||||
self.assert_not_image(self.without_segments(REAL_IMAGES["jpeg_baseline"][1], 0xDB))
|
||||
|
||||
def test_without_huffman_tables_like_mjpeg(self):
|
||||
# кадры MJPEG хранятся без таблиц Хаффмана, декодер подставляет стандартные: такой файл корректен
|
||||
stripped = self.without_segments(REAL_IMAGES["jpeg_baseline"][1], 0xC4)
|
||||
self.assertEqual(inspect(stripped), "image/jpeg")
|
||||
|
||||
def test_scan_replaced_by_almost_nothing(self):
|
||||
data = REAL_IMAGES["jpeg_baseline"][1]
|
||||
start, length = self.segment(data, 0xDA)
|
||||
self.assert_not_image(data[:start + length] + b"\xff\xd9")
|
||||
self.assert_not_image(data[:start + length] + b"\x12" + b"\xff\xd9")
|
||||
|
||||
def test_truncated_with_end_marker_added(self):
|
||||
for name in ("jpeg_baseline", "jpeg_progressive"):
|
||||
data = REAL_IMAGES[name][1]
|
||||
start, length = self.segment(data, 0xDA)
|
||||
with self.subTest(name):
|
||||
self.assert_not_image(data[:start + length + 1] + b"\xff\xd9")
|
||||
|
||||
def test_big_frame_with_tiny_scan(self):
|
||||
data = bytearray(REAL_IMAGES["jpeg_baseline"][1])
|
||||
start, _ = self.segment(bytes(data), 0xC0)
|
||||
data[start + 5:start + 9] = struct.pack(">HH", 4000, 4000)
|
||||
self.assert_not_image(bytes(data))
|
||||
|
||||
def test_broken_frame_header(self):
|
||||
data = bytearray(REAL_IMAGES["jpeg_baseline"][1])
|
||||
start, _ = self.segment(bytes(data), 0xC0)
|
||||
for offset, value in ((9, 2), (9, 5), (11, 0x00), (11, 0x55)):
|
||||
broken = bytearray(data)
|
||||
broken[start + offset] = value
|
||||
with self.subTest(offset=offset, value=value):
|
||||
self.assert_not_image(bytes(broken))
|
||||
|
||||
def test_too_many_scans(self):
|
||||
# прогрессивный файл, где скан повторён тысячи раз: декодер прошёл бы всё изображение каждый раз
|
||||
data = REAL_IMAGES["jpeg_progressive"][1]
|
||||
start, length = self.segment(data, 0xDA)
|
||||
scan = data[start:start + length] + b"\x00" * 4
|
||||
self.assert_not_image(data[:start] + scan * (images.MAX_JPEG_SCANS + 1) + b"\xff\xd9")
|
||||
|
||||
|
||||
class PixelLimitTest(unittest.TestCase):
|
||||
def test_png_bomb_is_rejected_before_unpacking(self):
|
||||
header = struct.pack(">IIBBBBB", 50000, 50000, 8, 2, 0, 0, 0)
|
||||
# данные заголовка верны, а распаковать пришлось бы 7,5 ГБ
|
||||
data = b"\x89PNG\r\n\x1a\n" + png_chunk(b"IHDR", header) + png_chunk(b"IDAT", zlib.compress(b"\x00" * 1000))
|
||||
with self.assertRaises(images.TooManyPixels):
|
||||
inspect(data)
|
||||
|
||||
def test_jpeg_over_limit(self):
|
||||
data = bytearray(REAL_IMAGES["jpeg_baseline"][1])
|
||||
start = data.index(b"\xff\xc0")
|
||||
data[start + 5:start + 9] = struct.pack(">HH", 20000, 20000)
|
||||
with self.assertRaises(images.TooManyPixels):
|
||||
inspect(bytes(data))
|
||||
|
||||
def test_limit_is_exact(self):
|
||||
self.assertEqual(inspect(make_png(10, 10), limit=100), "image/png")
|
||||
with self.assertRaises(images.TooManyPixels):
|
||||
inspect(make_png(10, 10), limit=99)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,103 @@
|
||||
"""Настоящие маленькие изображения, созданы Pillow, и сборка синтетических PNG."""
|
||||
import base64
|
||||
import struct
|
||||
import zlib
|
||||
from random import Random
|
||||
|
||||
REAL_IMAGES = {
|
||||
"jpeg_baseline": ("image/jpeg", base64.b64decode(
|
||||
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAoHBwgHBgoICAgLCgoLDhgQDg0NDh0VFhEYIx8lJCIfIiEmKzcvJik0KSEiMEExNDk7"
|
||||
"Pj4+JS5ESUM8SDc9Pjv/2wBDAQoLCw4NDhwQEBw7KCIoOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7"
|
||||
"Ozs7Ozs7Ozv/wAARCAAQABgDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUF"
|
||||
"BAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW"
|
||||
"V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi"
|
||||
"4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAEC"
|
||||
"AxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVm"
|
||||
"Z2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq"
|
||||
"8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDz220fp8ta9to/T5a6W20fp8ta9to/T5a5YYg4sBm22pzNto/T5aK7y20fp8tFdKxGh9nQ"
|
||||
"zb3Nz//Z"
|
||||
)),
|
||||
"jpeg_progressive": ("image/jpeg", base64.b64decode(
|
||||
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAoHBwgHBgoICAgLCgoLDhgQDg0NDh0VFhEYIx8lJCIfIiEmKzcvJik0KSEiMEExNDk7"
|
||||
"Pj4+JS5ESUM8SDc9Pjv/2wBDAQoLCw4NDhwQEBw7KCIoOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7"
|
||||
"Ozs7Ozs7Ozv/wgARCAAQABgDASIAAhEBAxEB/8QAFwAAAwEAAAAAAAAAAAAAAAAAAAQFBv/EABUBAQEAAAAAAAAAAAAAAAAAAAMF"
|
||||
"/9oADAMBAAIQAxAAAAHPN02yCYXhLX//xAAWEAADAAAAAAAAAAAAAAAAAAAAAgP/2gAIAQEAAQUCWIsRYixFiLE//8QAGBEAAgMA"
|
||||
"AAAAAAAAAAAAAAAAAAQCAyH/2gAIAQMBAT8BobIN4f/EABcRAQADAAAAAAAAAAAAAAAAAAABAxP/2gAIAQIBAT8Bixo//8QAFBAB"
|
||||
"AAAAAAAAAAAAAAAAAAAAIP/aAAgBAQAGPwJf/8QAFRABAQAAAAAAAAAAAAAAAAAAAGH/2gAIAQEAAT8hgggggg//2gAMAwEAAgAD"
|
||||
"AAAAEFfv/8QAFxEBAAMAAAAAAAAAAAAAAAAAACExUf/aAAgBAwEBPxCqW1//xAAWEQEBAQAAAAAAAAAAAAAAAAAAASH/2gAIAQIB"
|
||||
"AT8QUw//xAAVEAEBAAAAAAAAAAAAAAAAAAAAMf/aAAgBAQABPxCRIkSJEj//2Q=="
|
||||
)),
|
||||
"jpeg_gray": ("image/jpeg", base64.b64decode(
|
||||
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAx"
|
||||
"NDQ0Hyc5PTgyPC4zNDL/wAALCAAQABgBAREA/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUF"
|
||||
"BAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW"
|
||||
"V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi"
|
||||
"4+Tl5ufo6erx8vP09fb3+Pn6/9oACAEBAAA/APLLTQ+nyVu2mh9PkrctND6fJWlaaH0+St200Pp8lblpofT5K//Z"
|
||||
)),
|
||||
"jpeg_cmyk": ("image/jpeg", base64.b64decode(
|
||||
"/9j/7gAOQWRvYmUAZAAAAAAA/9sAQwAIBgYHBgUIBwcHCQkICgwUDQwLCwwZEhMPFB0aHx4dGhwcICQuJyAiLCMcHCg3KSwwMTQ0"
|
||||
"NB8nOT04MjwuMzQy/8AAFAgAEAAYBEMRAE0RAFkRAEsRAP/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIB"
|
||||
"AwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZH"
|
||||
"SElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV"
|
||||
"1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/aAA4EQwBNAFkASwAAPwDyLQf4a8z/AOER/wCmf6V5FYWHTivf69Q0H+Gj/hEf+mf6"
|
||||
"V1FhYdOKK9Q0H+Gj/hEf+mf6V1FhYdOKK+X9B/hr3n/hEf8Apn+lcvYWHTiivUNB/ho/4RH/AKZ/pXUWFh04or1DQf4aP+ER/wCm"
|
||||
"f6V1FhYdOKK//9k="
|
||||
)),
|
||||
"png_rgb": ("image/png", base64.b64decode(
|
||||
"iVBORw0KGgoAAAANSUhEUgAAABgAAAAQCAIAAACDRijCAAAAIklEQVR4nGNkYGDgYmClHLEw8LMyMFABjRo0atCoQSPVIACIwAmA"
|
||||
"4cyUgAAAAABJRU5ErkJggg=="
|
||||
)),
|
||||
"png_rgba": ("image/png", base64.b64decode(
|
||||
"iVBORw0KGgoAAAANSUhEUgAAABgAAAAQCAYAAAAMJL+VAAAAKUlEQVR4nGNkYGD4z8XAykArzMLAz8rAwEA7PGrBqAWjFoxaMGoB"
|
||||
"NTAAUr4Kf23u9hgAAAAASUVORK5CYII="
|
||||
)),
|
||||
"png_palette": ("image/png", base64.b64decode(
|
||||
"iVBORw0KGgoAAAANSUhEUgAAABgAAAAQCAMAAAA7+k+nAAACplBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAz"
|
||||
"AABmAACZAADMAAD/AAAAMwAzMwBmMwCZMwDMMwD/MwAAZgAzZgBmZgCZZgDMZgD/ZgAAmQAzmQBmmQCZmQDMmQD/mQAAzAAzzABm"
|
||||
"zACZzADMzAD/zAAA/wAz/wBm/wCZ/wDM/wD//wAAADMzADNmADOZADPMADP/ADMAMzMzMzNmMzOZMzPMMzP/MzMAZjMzZjNmZjOZ"
|
||||
"ZjPMZjP/ZjMAmTMzmTNmmTOZmTPMmTP/mTMAzDMzzDNmzDOZzDPMzDP/zDMA/zMz/zNm/zOZ/zPM/zP//zMAAGYzAGZmAGaZAGbM"
|
||||
"AGb/AGYAM2YzM2ZmM2aZM2bMM2b/M2YAZmYzZmZmZmaZZmbMZmb/ZmYAmWYzmWZmmWaZmWbMmWb/mWYAzGYzzGZmzGaZzGbMzGb/"
|
||||
"zGYA/2Yz/2Zm/2aZ/2bM/2b//2YAAJkzAJlmAJmZAJnMAJn/AJkAM5kzM5lmM5mZM5nMM5n/M5kAZpkzZplmZpmZZpnMZpn/ZpkA"
|
||||
"mZkzmZlmmZmZmZnMmZn/mZkAzJkzzJlmzJmZzJnMzJn/zJkA/5kz/5lm/5mZ/5nM/5n//5kAAMwzAMxmAMyZAMzMAMz/AMwAM8wz"
|
||||
"M8xmM8yZM8zMM8z/M8wAZswzZsxmZsyZZszMZsz/ZswAmcwzmcxmmcyZmczMmcz/mcwAzMwzzMxmzMyZzMzMzMz/zMwA/8wz/8xm"
|
||||
"/8yZ/8zM/8z//8wAAP8zAP9mAP+ZAP/MAP//AP8AM/8zM/9mM/+ZM//MM///M/8AZv8zZv9mZv+ZZv/MZv//Zv8Amf8zmf9mmf+Z"
|
||||
"mf/Mmf//mf8AzP8zzP9mzP+ZzP/MzP//zP8A//8z//9m//+Z///M//////91g91EAAABH0lEQVR4nC3LMW6DMBTGce8ssOQaBAkT"
|
||||
"KVAJOsAFSiIZqmJUoMJGart2IUOcwVTC7pBzdMnU3q3P0G/8/95DCCHLtVx3a+Z5uZcfzI7QXQRgbYG8By/PvYOhD2TbNnYwDnAQ"
|
||||
"BGRHdkVRwsYjsn3Hx7C1F9BBxvIE4DsrkMDcGxnL8RH5G+yHGEeYRIRQUtCiFOVYn9Bmvw/NoqeouqsopfW5FrW4IOhGIMOomaBC"
|
||||
"XATA8lGFVVRRkDPkWohPFMdJnDRJ05p1nezki5ymyUCcGLgH6lro3TT9Q/KcNE27vEiQSa6Qxn3WZKzhvOWqVYNUWmr9rVHaZz1j"
|
||||
"jDPOZ64GpZSG3b4AUpYZgT4PM3Slbwu8sv4N4J3N/Ar9CvKjb79/rgyKjTEBaRcAAAAASUVORK5CYII="
|
||||
)),
|
||||
"png_1bit": ("image/png", base64.b64decode(
|
||||
"iVBORw0KGgoAAAANSUhEUgAAABgAAAAQAQAAAAAkX4I4AAAAS0lEQVR4nAFAAL//AAAAAgAAEqkBAkLgARABRAEFRQAES9UEAQVM"
|
||||
"BQJN/P8BCRwwAaoLuQKo9UcC2AMmAaoMAQKr9bcAqt37AV8Y6K/aEe5QdGjgAAAAAElFTkSuQmCC"
|
||||
)),
|
||||
}
|
||||
|
||||
|
||||
def png_chunk(kind, data):
|
||||
return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data))
|
||||
|
||||
|
||||
def make_png(width, height, raw=None):
|
||||
"""PNG RGB с верными CRC. Без raw пиксели настоящие, с raw можно подложить любые данные."""
|
||||
if raw is None:
|
||||
row = b"\x00" + bytes(i % 251 for i in range(width * 3))
|
||||
raw = row * height
|
||||
header = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
|
||||
return b"\x89PNG\r\n\x1a\n" + png_chunk(b"IHDR", header) + png_chunk(b"IDAT", zlib.compress(raw)) + png_chunk(b"IEND", b"")
|
||||
|
||||
|
||||
def noisy_png(size):
|
||||
"""Настоящий PNG ровно из size байт. Случайные пиксели не сжимаются, поэтому файл действительно большой."""
|
||||
width = 1000
|
||||
row = 1 + width * 3
|
||||
height = (size - size // 500 - 200) // row
|
||||
random = Random(size)
|
||||
raw = b"".join(b"\x00" + random.randbytes(width * 3) for _ in range(height))
|
||||
header = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
|
||||
start = b"\x89PNG\r\n\x1a\n" + png_chunk(b"IHDR", header) + png_chunk(b"IDAT", zlib.compress(raw, 1))
|
||||
end = png_chunk(b"IEND", b"")
|
||||
# остаток добирается служебным блоком: он не меняет изображение
|
||||
padding = size - len(start) - len(end) - 12
|
||||
assert padding >= 0, "образец больше запрошенного размера"
|
||||
return start + png_chunk(b"tEXt", b"x" * padding) + end
|
||||
@@ -0,0 +1,85 @@
|
||||
import unittest
|
||||
import uuid
|
||||
|
||||
from api import call, new_chat, new_user, send
|
||||
|
||||
|
||||
class ForeignChatTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.alice, cls.bob, cls.eve = new_user("alice"), new_user("bob"), new_user("eve")
|
||||
cls.chat = new_chat(cls.alice, cls.bob)
|
||||
cls.path = "/api/v1/chats/" + cls.chat["id"]
|
||||
send(cls.alice, cls.chat, "секрет")
|
||||
|
||||
def test_outsider_gets_404_everywhere(self):
|
||||
self.assertEqual(call("GET", self.path, user=self.eve)[0], 404)
|
||||
self.assertEqual(call("GET", self.path + "/messages", user=self.eve)[0], 404)
|
||||
status, body, _ = send(self.eve, self.chat, "я тут")
|
||||
self.assertEqual(status, 404)
|
||||
self.assertEqual(body["error"]["code"], "not_found")
|
||||
|
||||
def test_foreign_chat_looks_like_missing_chat(self):
|
||||
_, foreign, _ = call("GET", self.path, user=self.eve)
|
||||
_, missing, _ = call("GET", "/api/v1/chats/" + str(uuid.uuid4()), user=self.eve)
|
||||
self.assertEqual(foreign["error"]["message"], missing["error"]["message"])
|
||||
|
||||
def test_outsider_message_is_not_saved(self):
|
||||
send(self.eve, self.chat, "не должно появиться")
|
||||
_, page, _ = call("GET", self.path + "/messages", user=self.alice)
|
||||
self.assertNotIn("не должно появиться", [item["text"] for item in page["items"]])
|
||||
|
||||
def test_chat_is_not_listed_for_outsider(self):
|
||||
_, page, _ = call("GET", "/api/v1/chats?limit=100", user=self.eve)
|
||||
self.assertNotIn(self.chat["id"], [item["id"] for item in page["items"]])
|
||||
_, page, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob)
|
||||
self.assertIn(self.chat["id"], [item["id"] for item in page["items"]])
|
||||
|
||||
def test_members_can_read_and_write(self):
|
||||
self.assertEqual(send(self.bob, self.chat, "ответ")[0], 201)
|
||||
self.assertEqual(call("GET", self.path, user=self.bob)[0], 200)
|
||||
|
||||
def test_bad_chat_id(self):
|
||||
chat_id = self.chat["id"]
|
||||
for bad in ("123", chat_id.replace("-", ""), "urn:uuid:" + chat_id):
|
||||
with self.subTest(chat_id=bad):
|
||||
self.assertEqual(call("GET", "/api/v1/chats/" + bad, user=self.alice)[0], 400)
|
||||
self.assertEqual(call("GET", "/api/v1/chats/" + bad + "/messages", user=self.alice)[0], 400)
|
||||
|
||||
def test_member_id_must_be_canonical_uuid(self):
|
||||
body = {"title": "Чат", "member_ids": ["urn:uuid:" + self.alice["id"]]}
|
||||
self.assertEqual(call("POST", "/api/v1/chats", body, user=self.alice)[0], 400)
|
||||
|
||||
|
||||
class CreateChatTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.alice, cls.bob = new_user("alice"), new_user("bob")
|
||||
|
||||
def create(self, member_ids, title="Чат"):
|
||||
return call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=self.alice)[0]
|
||||
|
||||
def test_creator_must_be_member(self):
|
||||
self.assertEqual(self.create([self.bob["id"]]), 400)
|
||||
|
||||
def test_duplicate_members(self):
|
||||
self.assertEqual(self.create([self.alice["id"], self.bob["id"], self.bob["id"]]), 400)
|
||||
|
||||
def test_unknown_member(self):
|
||||
self.assertEqual(self.create([self.alice["id"], str(uuid.uuid4())]), 400)
|
||||
|
||||
def test_empty_members(self):
|
||||
self.assertEqual(self.create([]), 400)
|
||||
|
||||
def test_blank_title(self):
|
||||
self.assertEqual(self.create([self.alice["id"]], title=" "), 400)
|
||||
|
||||
def test_failed_create_leaves_no_chat(self):
|
||||
_, before, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob)
|
||||
self.create([self.alice["id"], self.bob["id"], str(uuid.uuid4())])
|
||||
_, after, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob)
|
||||
self.assertEqual(before, after)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,320 @@
|
||||
import hashlib
|
||||
import socket
|
||||
import unittest
|
||||
import urllib.parse
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
from api import BASE_URL, call, history, new_chat, new_key, new_user, request_bytes, send
|
||||
from samples import REAL_IMAGES, make_png, noisy_png
|
||||
|
||||
FIXTURE = (Path(__file__).resolve().parents[1] / "tests/fixtures/sample.png").read_bytes()
|
||||
MIB = 1024 * 1024
|
||||
|
||||
|
||||
def upload(user, chat, data, content_type="image/png", filename="photo.png", headers=None):
|
||||
path = "/api/v1/chats/%s/attachments" % chat["id"]
|
||||
if filename is not None:
|
||||
path += "?filename=" + urllib.parse.quote(filename, safe="")
|
||||
return call("POST", path, raw=data, user=user, headers={"Content-Type": content_type, **(headers or {})})
|
||||
|
||||
|
||||
def content(user, attachment_id, query=""):
|
||||
return request_bytes("GET", "/api/v1/attachments/%s/content%s" % (attachment_id, query), user=user)
|
||||
|
||||
|
||||
class Base(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.alice, cls.bob, cls.eve = new_user("alice"), new_user("bob"), new_user("eve")
|
||||
cls.chat = new_chat(cls.alice, cls.bob)
|
||||
|
||||
def assert_error(self, result, status, code):
|
||||
got, body, headers = result
|
||||
self.assertEqual(got, status)
|
||||
self.assertEqual(body["error"]["code"], code)
|
||||
self.assertEqual(body["error"]["request_id"], headers["X-Request-Id"])
|
||||
|
||||
|
||||
class UploadTest(Base):
|
||||
def test_upload_and_download_real_images(self):
|
||||
for name, (content_type, data) in REAL_IMAGES.items():
|
||||
with self.subTest(name):
|
||||
status, attachment, _ = upload(self.alice, self.chat, data, content_type, name)
|
||||
self.assertEqual(status, 201)
|
||||
self.assertEqual(attachment["content_type"], content_type)
|
||||
self.assertEqual(attachment["sha256"], hashlib.sha256(data).hexdigest())
|
||||
got, body, headers = content(self.bob, attachment["id"])
|
||||
self.assertEqual(got, 200)
|
||||
self.assertEqual(body, data)
|
||||
self.assertEqual(headers.get_content_type(), content_type)
|
||||
|
||||
def test_attachment_fields(self):
|
||||
status, attachment, _ = upload(self.alice, self.chat, FIXTURE, filename="отчёт 👋.png")
|
||||
self.assertEqual(status, 201)
|
||||
self.assertEqual(attachment["status"], "ready")
|
||||
self.assertEqual(attachment["variants"], [])
|
||||
self.assertIsNone(attachment["error_code"])
|
||||
self.assertEqual(attachment["filename"], "отчёт 👋.png")
|
||||
self.assertEqual(attachment["owner_id"], self.alice["id"])
|
||||
self.assertEqual(attachment["size_bytes"], len(FIXTURE))
|
||||
self.assertEqual(call("GET", "/api/v1/attachments/" + attachment["id"], user=self.bob)[1], attachment)
|
||||
|
||||
def test_download_headers(self):
|
||||
_, attachment, _ = upload(self.alice, self.chat, FIXTURE, filename="отчёт.png")
|
||||
_, _, headers = content(self.alice, attachment["id"])
|
||||
self.assertEqual(headers["X-Content-Type-Options"], "nosniff")
|
||||
self.assertIn("filename*=UTF-8''", headers["Content-Disposition"])
|
||||
self.assertEqual(headers["Content-Length"], str(len(FIXTURE)))
|
||||
|
||||
def test_file_of_exactly_10_mib(self):
|
||||
data = noisy_png(10 * MIB)
|
||||
self.assertEqual(len(data), 10 * MIB)
|
||||
status, attachment, _ = upload(self.alice, self.chat, data)
|
||||
self.assertEqual(status, 201)
|
||||
got, body, _ = content(self.bob, attachment["id"])
|
||||
self.assertEqual((got, hashlib.sha256(body).hexdigest()), (200, attachment["sha256"]))
|
||||
|
||||
def test_one_byte_over_10_mib(self):
|
||||
self.assert_error(upload(self.alice, self.chat, noisy_png(10 * MIB + 1)), 413, "payload_too_large")
|
||||
|
||||
|
||||
class LimitsTest(Base):
|
||||
def test_too_large_with_length(self):
|
||||
self.assert_error(upload(self.alice, self.chat, b"\x89PNG" + b"x" * (10 * MIB)), 413, "payload_too_large")
|
||||
|
||||
def test_too_large_for_balancer(self):
|
||||
self.assert_error(upload(self.alice, self.chat, b"x" * (12 * MIB)), 413, "payload_too_large")
|
||||
|
||||
def test_too_large_chunked(self):
|
||||
# без Content-Length размер известен только по ходу чтения
|
||||
address = urllib.parse.urlsplit(BASE_URL)
|
||||
path = "/api/v1/chats/%s/attachments?filename=a.png" % self.chat["id"]
|
||||
head = ("POST %s HTTP/1.1\r\nHost: x\r\nContent-Type: image/png\r\nAuthorization: Bearer %s\r\n"
|
||||
"Transfer-Encoding: chunked\r\n\r\n" % (path, self.alice["token"])).encode()
|
||||
with socket.create_connection((address.hostname, address.port), timeout=15) as connection:
|
||||
connection.sendall(head)
|
||||
block = b"x" * MIB
|
||||
try:
|
||||
for _ in range(12):
|
||||
connection.sendall(b"100000\r\n" + block + b"\r\n")
|
||||
connection.sendall(b"0\r\n\r\n")
|
||||
except OSError:
|
||||
pass # сервер закрыл соединение, не дочитав: это и нужно
|
||||
self.assertIn(b" 413 ", connection.recv(4096).split(b"\r\n")[0])
|
||||
|
||||
def test_decompression_bomb(self):
|
||||
data = make_png(50000, 50000, b"\x00" * 1000)
|
||||
self.assert_error(upload(self.alice, self.chat, data), 413, "payload_too_large")
|
||||
|
||||
def test_pixels_over_limit_with_small_file(self):
|
||||
self.assert_error(upload(self.alice, self.chat, make_png(8000, 8000, b"\x00" * 100)), 413, "payload_too_large")
|
||||
|
||||
def test_empty_file(self):
|
||||
self.assert_error(upload(self.alice, self.chat, b""), 415, "unsupported_media_type")
|
||||
|
||||
|
||||
class ContentCheckTest(Base):
|
||||
def test_broken_images(self):
|
||||
png, jpeg = FIXTURE, REAL_IMAGES["jpeg_baseline"][1]
|
||||
flipped = bytearray(png)
|
||||
flipped[len(png) // 2] ^= 0xFF
|
||||
cases = {
|
||||
"текст": (b"not an image at all", "image/png"),
|
||||
"обрезанный PNG": (png[: len(png) // 2], "image/png"),
|
||||
"обрезанный JPEG": (jpeg[: len(jpeg) // 2], "image/jpeg"),
|
||||
"только сигнатура PNG": (png[:8], "image/png"),
|
||||
"только сигнатура JPEG": (jpeg[:3], "image/jpeg"),
|
||||
"испорченный байт в PNG": (bytes(flipped), "image/png"),
|
||||
"GIF": (b"GIF89a" + b"\x00" * 100, "image/png"),
|
||||
"SVG": (b"<svg xmlns='http://www.w3.org/2000/svg'/>", "image/png"),
|
||||
}
|
||||
for name, (data, content_type) in cases.items():
|
||||
with self.subTest(name):
|
||||
self.assert_error(upload(self.alice, self.chat, data, content_type), 415, "unsupported_media_type")
|
||||
|
||||
def test_files_from_review(self):
|
||||
png = make_png(1, 1, b"\xff\x00\x00\x00")
|
||||
jpeg = bytes.fromhex("ffd8ffc0000b080001000101011100ffda0008010100003f00ffd9")
|
||||
self.assert_error(upload(self.alice, self.chat, png), 415, "unsupported_media_type")
|
||||
self.assert_error(upload(self.alice, self.chat, jpeg, "image/jpeg"), 415, "unsupported_media_type")
|
||||
|
||||
def test_mime_spoofing(self):
|
||||
png, jpeg = FIXTURE, REAL_IMAGES["jpeg_baseline"][1]
|
||||
self.assert_error(upload(self.alice, self.chat, png, "image/jpeg"), 415, "unsupported_media_type")
|
||||
self.assert_error(upload(self.alice, self.chat, jpeg, "image/png"), 415, "unsupported_media_type")
|
||||
|
||||
def test_unsupported_content_type(self):
|
||||
for content_type in ("image/gif", "text/html", "application/octet-stream", "multipart/form-data"):
|
||||
with self.subTest(content_type):
|
||||
self.assert_error(upload(self.alice, self.chat, FIXTURE, content_type), 415, "unsupported_media_type")
|
||||
|
||||
def test_extension_is_not_trusted(self):
|
||||
status, attachment, _ = upload(self.alice, self.chat, FIXTURE, filename="evil.exe")
|
||||
self.assertEqual((status, attachment["content_type"]), (201, "image/png"))
|
||||
|
||||
|
||||
class FilenameTest(Base):
|
||||
def test_bad_filenames(self):
|
||||
names = ("", " ", "a/b.png", "../../etc/passwd", "a\\b.png", "a\x00b.png", "a\nb.png", "a\tb.png", "a\x7fb.png",
|
||||
".", "..", "x" * 256, "photognp.exe")
|
||||
for name in names:
|
||||
with self.subTest(name=ascii(name[:20])):
|
||||
self.assert_error(upload(self.alice, self.chat, FIXTURE, filename=name), 400, "invalid_request")
|
||||
|
||||
def test_missing_filename(self):
|
||||
self.assert_error(upload(self.alice, self.chat, FIXTURE, filename=None), 400, "invalid_request")
|
||||
|
||||
def test_good_filenames(self):
|
||||
for name in ("a", "x" * 255, "я" * 255, "two words.png", "семья 👨👩👧.jpg", ".hidden.png", "'; DROP TABLE users; --.png"):
|
||||
with self.subTest(name=name[:20]):
|
||||
status, attachment, _ = upload(self.alice, self.chat, FIXTURE, filename=name)
|
||||
self.assertEqual((status, attachment["filename"]), (201, name))
|
||||
|
||||
|
||||
class AccessTest(Base):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
super().setUpClass()
|
||||
_, cls.attachment, _ = upload(cls.alice, cls.chat, FIXTURE)
|
||||
cls.other_chat = new_chat(cls.eve)
|
||||
|
||||
def test_outsider_gets_404(self):
|
||||
attachment_id = self.attachment["id"]
|
||||
self.assert_error(call("GET", "/api/v1/attachments/" + attachment_id, user=self.eve), 404, "not_found")
|
||||
self.assertEqual(content(self.eve, attachment_id)[0], 404)
|
||||
|
||||
def test_outsider_looks_the_same_as_missing(self):
|
||||
_, foreign, _ = call("GET", "/api/v1/attachments/" + self.attachment["id"], user=self.eve)
|
||||
_, missing, _ = call("GET", "/api/v1/attachments/" + str(uuid.uuid4()), user=self.eve)
|
||||
self.assertEqual(foreign["error"]["message"], missing["error"]["message"])
|
||||
|
||||
def test_no_token(self):
|
||||
self.assertEqual(call("GET", "/api/v1/attachments/" + self.attachment["id"])[0], 401)
|
||||
self.assertEqual(content({"token": "x" * 43}, self.attachment["id"])[0], 401)
|
||||
self.assertEqual(upload({"token": "x" * 43}, self.chat, FIXTURE)[0], 401)
|
||||
|
||||
def test_outsider_cannot_upload(self):
|
||||
self.assert_error(upload(self.eve, self.chat, FIXTURE), 404, "not_found")
|
||||
|
||||
def test_bad_ids(self):
|
||||
self.assertEqual(call("GET", "/api/v1/attachments/123", user=self.alice)[0], 400)
|
||||
self.assertEqual(call("GET", "/api/v1/attachments/urn:uuid:" + self.attachment["id"], user=self.alice)[0], 400)
|
||||
|
||||
def test_download_never_redirects(self):
|
||||
status, body, headers = content(self.bob, self.attachment["id"])
|
||||
self.assertEqual(status, 200)
|
||||
self.assertIsNone(headers.get("Location"))
|
||||
self.assertNotIn(b"X-Amz", body[:200])
|
||||
|
||||
def test_variants(self):
|
||||
attachment_id = self.attachment["id"]
|
||||
self.assertEqual(content(self.bob, attachment_id, "?variant=original")[0], 200)
|
||||
self.assertEqual(content(self.bob, attachment_id, "?variant=thumbnail")[0], 404)
|
||||
self.assertEqual(content(self.bob, attachment_id, "?variant=nonsense")[0], 400)
|
||||
self.assertEqual(content(self.eve, attachment_id, "?variant=nonsense")[0], 404)
|
||||
|
||||
|
||||
class MessageLinkTest(Base):
|
||||
def test_message_with_attachments(self):
|
||||
ids = [upload(self.alice, self.chat, FIXTURE)[1]["id"] for _ in range(2)]
|
||||
status, message, _ = send(self.alice, self.chat, "смотри", attachment_ids=ids)
|
||||
self.assertEqual((status, message["attachment_ids"]), (201, ids))
|
||||
items, _ = history(self.bob, self.chat, 100)
|
||||
self.assertIn(message, items)
|
||||
|
||||
def test_attachment_only_message(self):
|
||||
attachment_id = upload(self.alice, self.chat, FIXTURE)[1]["id"]
|
||||
status, message, _ = send(self.bob, self.chat, "", attachment_ids=[attachment_id])
|
||||
self.assertEqual((status, message["text"]), (201, ""))
|
||||
|
||||
def test_text_message_has_empty_list(self):
|
||||
self.assertEqual(send(self.alice, self.chat, "текст")[1]["attachment_ids"], [])
|
||||
|
||||
def test_empty_message_without_attachments(self):
|
||||
self.assert_error(send(self.alice, self.chat, "", attachment_ids=[]), 400, "invalid_request")
|
||||
self.assert_error(send(self.alice, self.chat, " ", attachment_ids=[]), 400, "invalid_request")
|
||||
|
||||
def test_foreign_attachment(self):
|
||||
foreign_chat = new_chat(self.eve)
|
||||
foreign = upload(self.eve, foreign_chat, FIXTURE)[1]["id"]
|
||||
self.assert_error(send(self.alice, self.chat, "чужое", attachment_ids=[foreign]), 404, "not_found")
|
||||
|
||||
def test_attachment_of_my_other_chat(self):
|
||||
other = new_chat(self.alice)
|
||||
attachment_id = upload(self.alice, other, FIXTURE)[1]["id"]
|
||||
self.assert_error(send(self.alice, self.chat, "не тот чат", attachment_ids=[attachment_id]), 404, "not_found")
|
||||
|
||||
def test_unknown_attachment(self):
|
||||
self.assert_error(send(self.alice, self.chat, "нет", attachment_ids=[str(uuid.uuid4())]), 404, "not_found")
|
||||
|
||||
def test_failed_link_saves_nothing_and_frees_key(self):
|
||||
key = new_key()
|
||||
attachment_id = upload(self.alice, self.chat, FIXTURE)[1]["id"]
|
||||
self.assertEqual(send(self.alice, self.chat, "повтор", key=key, attachment_ids=[str(uuid.uuid4())])[0], 404)
|
||||
self.assertEqual(send(self.alice, self.chat, "повтор", key=key, attachment_ids=[attachment_id])[0], 201)
|
||||
|
||||
def test_limits(self):
|
||||
one = str(uuid.uuid4())
|
||||
self.assert_error(send(self.alice, self.chat, "x", attachment_ids=[one, one]), 400, "invalid_request")
|
||||
many = [str(uuid.uuid4()) for _ in range(11)]
|
||||
self.assert_error(send(self.alice, self.chat, "x", attachment_ids=many), 400, "invalid_request")
|
||||
self.assert_error(send(self.alice, self.chat, "x", attachment_ids=["abc"]), 400, "invalid_request")
|
||||
|
||||
def test_ten_attachments(self):
|
||||
ids = [upload(self.alice, self.chat, FIXTURE)[1]["id"] for _ in range(10)]
|
||||
self.assertEqual(send(self.alice, self.chat, "десять", attachment_ids=ids)[1]["attachment_ids"], ids)
|
||||
|
||||
def test_idempotent_repeat(self):
|
||||
attachment_id = upload(self.alice, self.chat, FIXTURE)[1]["id"]
|
||||
key = new_key()
|
||||
first = send(self.alice, self.chat, "с файлом", key=key, attachment_ids=[attachment_id])
|
||||
second = send(self.alice, self.chat, "с файлом", key=key, attachment_ids=[attachment_id])
|
||||
self.assertEqual(first[1], second[1])
|
||||
self.assertEqual(send(self.alice, self.chat, "с файлом", key=key)[0], 409)
|
||||
|
||||
def test_missing_list_equals_empty_list(self):
|
||||
key = new_key()
|
||||
first = send(self.alice, self.chat, "без файла", key=key)
|
||||
second = send(self.alice, self.chat, "без файла", key=key, attachment_ids=[])
|
||||
self.assertEqual(first[1], second[1])
|
||||
|
||||
def test_one_file_in_two_messages(self):
|
||||
attachment_id = upload(self.alice, self.chat, FIXTURE)[1]["id"]
|
||||
self.assertEqual(send(self.alice, self.chat, "первое", attachment_ids=[attachment_id])[0], 201)
|
||||
self.assertEqual(send(self.bob, self.chat, "второе", attachment_ids=[attachment_id])[0], 201)
|
||||
|
||||
|
||||
class ParallelLimitTest(Base):
|
||||
def test_too_many_parallel_uploads_get_429(self):
|
||||
address = urllib.parse.urlsplit(BASE_URL)
|
||||
path = "/api/v1/chats/%s/attachments?filename=a.png" % self.chat["id"]
|
||||
head = ("POST %s HTTP/1.1\r\nHost: x\r\nContent-Type: image/png\r\nContent-Length: 1000\r\n"
|
||||
"Authorization: Bearer %s\r\n\r\nabc" % (path, self.alice["token"])).encode()
|
||||
# начатые загрузки, которые ничего не досылают; на каждую реплику лимит 32
|
||||
connections = []
|
||||
answers = []
|
||||
try:
|
||||
for _ in range(80):
|
||||
connection = socket.create_connection((address.hostname, address.port), timeout=5)
|
||||
connection.sendall(head)
|
||||
connections.append(connection)
|
||||
import time
|
||||
|
||||
time.sleep(1.5)
|
||||
for connection in connections:
|
||||
connection.setblocking(False)
|
||||
try:
|
||||
answers.append(connection.recv(4096).split(b"\r\n")[0])
|
||||
except BlockingIOError:
|
||||
pass
|
||||
finally:
|
||||
for connection in connections:
|
||||
connection.close()
|
||||
self.assertTrue(answers, "ни одна лишняя загрузка не получила ответ")
|
||||
self.assertTrue(all(b" 429 " in answer for answer in answers), answers[:3])
|
||||
self.assertEqual(upload(self.alice, self.chat, FIXTURE)[0], 201)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,144 @@
|
||||
import datetime
|
||||
import unittest
|
||||
import uuid
|
||||
|
||||
from api import basic, call, login, new_user, user_body
|
||||
|
||||
|
||||
class LoginTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.body = user_body()
|
||||
_, cls.user, _ = call("POST", "/api/v1/users", cls.body)
|
||||
|
||||
def assert_basic_challenge(self, result):
|
||||
status, body, headers = result
|
||||
self.assertEqual(status, 401)
|
||||
self.assertEqual(body["error"]["code"], "unauthorized")
|
||||
self.assertTrue(headers["WWW-Authenticate"].startswith("Basic "))
|
||||
return body
|
||||
|
||||
def test_login(self):
|
||||
status, session, _ = login(self.body["username"], self.body["password"])
|
||||
self.assertEqual(status, 201)
|
||||
self.assertEqual(set(session), {"token", "token_type", "expires_at", "user"})
|
||||
self.assertEqual(session["token_type"], "Bearer")
|
||||
self.assertEqual(session["user"], self.user)
|
||||
self.assertGreaterEqual(len(session["token"]), 32)
|
||||
expires_at = datetime.datetime.fromisoformat(session["expires_at"][:-1] + "+00:00")
|
||||
left = (expires_at - datetime.datetime.now(datetime.timezone.utc)).total_seconds()
|
||||
self.assertTrue(300 <= left <= 3600 + 5, left)
|
||||
|
||||
def test_token_is_opaque_and_unique(self):
|
||||
first = login(self.body["username"], self.body["password"])[1]["token"]
|
||||
second = login(self.body["username"], self.body["password"])[1]["token"]
|
||||
self.assertNotEqual(first, second)
|
||||
for token in (first, second):
|
||||
self.assertNotIn(self.user["id"], token)
|
||||
self.assertNotIn(self.body["username"], token)
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user={"token": token})[0], 200)
|
||||
|
||||
def test_wrong_password_and_unknown_user_look_the_same(self):
|
||||
wrong = self.assert_basic_challenge(login(self.body["username"], "wrong-password-123"))
|
||||
unknown = self.assert_basic_challenge(login("nobody_" + uuid.uuid4().hex[:8], self.body["password"]))
|
||||
self.assertEqual(wrong["error"]["message"], unknown["error"]["message"])
|
||||
|
||||
def test_malformed_credentials(self):
|
||||
token = login(self.body["username"], self.body["password"])[1]["token"]
|
||||
for header in (None, "Basic", "Basic !!!not-base64!!!", "Basic bm8tY29sb24=", "Bearer " + token, "Basic 0KU6"):
|
||||
with self.subTest(header=header):
|
||||
headers = {"Authorization": header} if header else {}
|
||||
self.assert_basic_challenge(call("POST", "/api/v1/auth/sessions", headers=headers))
|
||||
|
||||
def test_garbage_after_basic_is_401_not_500(self):
|
||||
# значение заголовка приходит на сервер как latin-1, поэтому после Basic может оказаться не ASCII
|
||||
values = ("\u00e9", "\u00e9\u00e9\u00e9=", "\u00ff\u00fe", "//46cHc=", "=", "====", "a", " ", "A" * 5000, "Og==",
|
||||
"dXNlcjpwYXNz dXNlcjpwYXNz")
|
||||
for value in values:
|
||||
with self.subTest(value=ascii(value[:16])):
|
||||
result = call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + value})
|
||||
self.assert_basic_challenge(result)
|
||||
|
||||
def test_username_that_cannot_exist(self):
|
||||
for username in ("", "Has Space", "ab\u0000cd", "имя_кириллицей"):
|
||||
with self.subTest(username=username):
|
||||
self.assert_basic_challenge(login(username, self.body["password"]))
|
||||
|
||||
def test_colon_and_unicode_in_password(self):
|
||||
body = user_body(password="пароль:с:двоеточиями")
|
||||
self.assertEqual(call("POST", "/api/v1/users", body)[0], 201)
|
||||
self.assertEqual(login(body["username"], body["password"])[0], 201)
|
||||
self.assert_basic_challenge(login(body["username"], "пароль"))
|
||||
|
||||
|
||||
class BearerTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.alice, cls.eve = new_user("alice"), new_user("eve")
|
||||
|
||||
def assert_bearer_challenge(self, result):
|
||||
status, body, headers = result
|
||||
self.assertEqual(status, 401)
|
||||
self.assertEqual(body["error"]["code"], "unauthorized")
|
||||
self.assertTrue(headers["WWW-Authenticate"].startswith("Bearer "))
|
||||
|
||||
def test_no_token(self):
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/users/me"))
|
||||
|
||||
def test_unknown_tokens(self):
|
||||
for token in ("x" * 43, self.alice["id"], self.alice["username"], self.alice["token"][:-1]):
|
||||
with self.subTest(token=token[:8]):
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", user={"token": token}))
|
||||
|
||||
def test_garbage_token_is_401_not_500(self):
|
||||
for token in ("\u00e9", "\u00ff\u00fe", "a b", "x" * 10000):
|
||||
with self.subTest(token=ascii(token[:16])):
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", user={"token": token}))
|
||||
|
||||
def test_basic_is_not_accepted_on_business_endpoints(self):
|
||||
headers = basic(self.alice["username"], self.alice["password"])
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", headers=headers))
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/chats", headers=headers))
|
||||
|
||||
def test_x_user_id_gives_no_access(self):
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", headers={"X-User-Id": self.alice["id"]}))
|
||||
|
||||
def test_x_user_id_does_not_change_identity(self):
|
||||
status, me, _ = call("GET", "/api/v1/users/me", user=self.alice, headers={"X-User-Id": self.eve["id"]})
|
||||
self.assertEqual(status, 200)
|
||||
self.assertEqual(me, self.alice["user"])
|
||||
|
||||
def test_token_is_checked_before_anything_else(self):
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/chats/not-a-uuid"))
|
||||
self.assert_bearer_challenge(call("GET", "/api/v1/chats?limit=0"))
|
||||
self.assert_bearer_challenge(call("POST", "/api/v1/chats", {"title": 5}))
|
||||
|
||||
|
||||
class LogoutTest(unittest.TestCase):
|
||||
def test_logout_revokes_only_current_session(self):
|
||||
user = new_user()
|
||||
other_token = login(user["username"], user["password"])[1]["token"]
|
||||
|
||||
status, body, _ = call("DELETE", "/api/v1/auth/sessions/current", user=user)
|
||||
self.assertEqual(status, 204)
|
||||
self.assertIsNone(body)
|
||||
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user=user)[0], 401)
|
||||
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", user=user)[0], 401)
|
||||
# вторая сессия того же пользователя продолжает работать
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user={"token": other_token})[0], 200)
|
||||
|
||||
def test_login_again_after_logout(self):
|
||||
user = new_user()
|
||||
call("DELETE", "/api/v1/auth/sessions/current", user=user)
|
||||
status, session, _ = login(user["username"], user["password"])
|
||||
self.assertEqual(status, 201)
|
||||
self.assertNotEqual(session["token"], user["token"])
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user=session)[0], 200)
|
||||
|
||||
def test_logout_requires_token(self):
|
||||
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current")[0], 401)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,94 @@
|
||||
import json
|
||||
import socket
|
||||
import unittest
|
||||
import urllib.parse
|
||||
import uuid
|
||||
|
||||
from api import BASE_URL, basic, call, history, new_chat, new_user, send
|
||||
|
||||
|
||||
class ErrorsFromBalancerTest(unittest.TestCase):
|
||||
"""Запросы, которые до API не доходят: ответ всё равно в формате контракта."""
|
||||
|
||||
def assert_contract_error(self, raw_request):
|
||||
address = urllib.parse.urlsplit(BASE_URL)
|
||||
with socket.create_connection((address.hostname, address.port), timeout=5) as connection:
|
||||
connection.sendall(raw_request)
|
||||
data = b""
|
||||
while chunk := connection.recv(65536):
|
||||
data += chunk
|
||||
head, _, body = data.partition(b"\r\n\r\n")
|
||||
lines = head.decode("latin-1").split("\r\n")
|
||||
headers = {line.split(":")[0].lower(): line.split(":", 1)[1].strip() for line in lines[1:]}
|
||||
self.assertEqual(headers["content-type"], "application/json")
|
||||
error = json.loads(body)["error"]
|
||||
self.assertEqual(error["request_id"], headers["x-request-id"])
|
||||
self.assertEqual(error["code"], "invalid_request")
|
||||
return int(lines[0].split()[1])
|
||||
|
||||
def test_invalid_http(self):
|
||||
self.assertEqual(self.assert_contract_error(b"GET /a b HTTP/1.1\r\nHost: x\r\n\r\n"), 400)
|
||||
|
||||
def test_too_long_uri(self):
|
||||
self.assertEqual(self.assert_contract_error(b"GET /" + b"a" * 20000 + b" HTTP/1.1\r\nHost: x\r\n\r\n"), 414)
|
||||
|
||||
def test_too_large_headers(self):
|
||||
raw = b"GET /x HTTP/1.1\r\nHost: x\r\nX-Big: " + b"a" * 20000 + b"\r\n\r\n"
|
||||
self.assertEqual(self.assert_contract_error(raw), 431)
|
||||
|
||||
|
||||
class ReplicasTest(unittest.TestCase):
|
||||
def test_every_answer_has_instance_id(self):
|
||||
user = new_user()
|
||||
answers = (
|
||||
call("GET", "/health/live"),
|
||||
call("GET", "/health/ready"),
|
||||
call("GET", "/api/v1/users/me"),
|
||||
call("GET", "/api/v1/users/me", user=user),
|
||||
call("GET", "/api/v1/chats/" + str(uuid.uuid4()), user=user),
|
||||
call("GET", "/nowhere"),
|
||||
call("POST", "/api/v1/users", raw=b"{"),
|
||||
)
|
||||
for status, _, headers in answers:
|
||||
with self.subTest(status=status):
|
||||
self.assertTrue(headers["X-Instance-Id"])
|
||||
self.assertTrue(headers["X-Request-Id"])
|
||||
|
||||
def test_one_session_is_served_by_different_replicas(self):
|
||||
user = new_user()
|
||||
instances = set()
|
||||
for _ in range(20):
|
||||
status, me, headers = call("GET", "/api/v1/users/me", user=user)
|
||||
self.assertEqual((status, me), (200, user["user"]))
|
||||
instances.add(headers["X-Instance-Id"])
|
||||
self.assertGreaterEqual(len(instances), 2)
|
||||
|
||||
def test_session_created_on_one_replica_works_on_all(self):
|
||||
user = new_user()
|
||||
for _ in range(6):
|
||||
status, session, _ = call("POST", "/api/v1/auth/sessions", headers=basic(user["username"], user["password"]))
|
||||
self.assertEqual(status, 201)
|
||||
seen = {call("GET", "/api/v1/users/me", user=session)[2]["X-Instance-Id"] for _ in range(4)}
|
||||
self.assertGreaterEqual(len(seen), 2)
|
||||
|
||||
def test_read_after_write_on_any_replica(self):
|
||||
user = new_user()
|
||||
chat = new_chat(user)
|
||||
for number in range(20):
|
||||
_, message, _ = send(user, chat, "запись %d" % number)
|
||||
items, _ = history(user, chat, 100)
|
||||
self.assertEqual(items[-1], message)
|
||||
|
||||
def test_logout_works_on_all_replicas(self):
|
||||
user = new_user()
|
||||
call("DELETE", "/api/v1/auth/sessions/current", user=user)
|
||||
for _ in range(4):
|
||||
self.assertEqual(call("GET", "/api/v1/users/me", user=user)[0], 401)
|
||||
|
||||
def test_no_sticky_cookie(self):
|
||||
_, _, headers = call("GET", "/health/live")
|
||||
self.assertIsNone(headers.get("Set-Cookie"), BASE_URL)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,63 @@
|
||||
"""Проверка гонок: 10 клиентов параллельно отправляют 100 сообщений в один чат."""
|
||||
import threading
|
||||
import unittest
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
from api import call, history, new_chat, new_user, send, user_body
|
||||
|
||||
CLIENTS = 10
|
||||
MESSAGES_PER_CLIENT = 10
|
||||
|
||||
|
||||
class ConcurrencyTest(unittest.TestCase):
|
||||
def test_100_messages_from_10_clients(self):
|
||||
users = [new_user("c%d" % number) for number in range(CLIENTS)]
|
||||
chat = new_chat(users[0], *users[1:])
|
||||
barrier = threading.Barrier(CLIENTS)
|
||||
|
||||
def client(number):
|
||||
barrier.wait() # все потоки стартуют одновременно
|
||||
results = []
|
||||
for index in range(MESSAGES_PER_CLIENT):
|
||||
results.append(send(users[number], chat, "клиент %d сообщение %d" % (number, index)))
|
||||
return results
|
||||
|
||||
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
|
||||
results = [result for chunk in pool.map(client, range(CLIENTS)) for result in chunk]
|
||||
|
||||
total = CLIENTS * MESSAGES_PER_CLIENT
|
||||
self.assertEqual([status for status, _, _ in results], [201] * total)
|
||||
confirmed = {message["id"]: message for _, message, _ in results}
|
||||
self.assertEqual(len(confirmed), total)
|
||||
|
||||
items, _ = history(users[0], chat, limit=7)
|
||||
self.assertEqual(len(items), total)
|
||||
self.assertEqual(len({item["id"] for item in items}), total)
|
||||
self.assertEqual(len({item["text"] for item in items}), total)
|
||||
# каждое подтверждённое сообщение есть в истории без изменений
|
||||
self.assertEqual({item["id"]: item for item in items}, confirmed)
|
||||
keys = [(item["created_at"], item["id"]) for item in items]
|
||||
self.assertEqual(keys, sorted(keys))
|
||||
# сообщения одного клиента идут в том порядке, в котором он их отправлял
|
||||
for number in range(CLIENTS):
|
||||
own = [item["text"] for item in items if item["sender_id"] == users[number]["id"]]
|
||||
self.assertEqual(own, ["клиент %d сообщение %d" % (number, index) for index in range(MESSAGES_PER_CLIENT)])
|
||||
print("\nотправлено %d, подтверждено %d, в истории %d, уникальных id %d"
|
||||
% (total, len(confirmed), len(items), len({item["id"] for item in items})))
|
||||
|
||||
def test_same_username_registered_once(self):
|
||||
body = user_body(username="race_" + uuid.uuid4().hex[:8])
|
||||
barrier = threading.Barrier(CLIENTS)
|
||||
|
||||
def register(_):
|
||||
barrier.wait()
|
||||
return call("POST", "/api/v1/users", body)[0]
|
||||
|
||||
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
|
||||
statuses = sorted(pool.map(register, range(CLIENTS)))
|
||||
self.assertEqual(statuses, [201] + [409] * (CLIENTS - 1))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,98 @@
|
||||
import threading
|
||||
import unittest
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
from api import call, history, new_chat, new_key, new_user, send
|
||||
|
||||
|
||||
class IdempotencyTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.alice, cls.bob, cls.eve = new_user("alice"), new_user("bob"), new_user("eve")
|
||||
cls.chat = new_chat(cls.alice, cls.bob)
|
||||
cls.path = "/api/v1/chats/" + cls.chat["id"] + "/messages"
|
||||
|
||||
def test_key_is_required(self):
|
||||
status, body, _ = call("POST", self.path, {"text": "без ключа"}, user=self.alice)
|
||||
self.assertEqual(status, 400)
|
||||
self.assertEqual(body["error"]["code"], "invalid_request")
|
||||
|
||||
def test_bad_keys(self):
|
||||
for key in ("", "a" * 129, "с пробелом", "кириллица", "a/b", "a,b"):
|
||||
with self.subTest(key=key[:12]):
|
||||
headers = {"Idempotency-Key": key.encode("utf-8").decode("latin-1")}
|
||||
self.assertEqual(call("POST", self.path, {"text": "x"}, user=self.alice, headers=headers)[0], 400)
|
||||
|
||||
def test_good_key_alphabet(self):
|
||||
for key in ("a", "A.b_c:d-1", "x" * 128):
|
||||
with self.subTest(key=key[:12]):
|
||||
self.assertEqual(send(self.alice, self.chat, "ключ " + key, key=key)[0], 201)
|
||||
|
||||
def test_repeat_returns_same_message(self):
|
||||
key = new_key()
|
||||
first = send(self.alice, self.chat, "Привет 👋", key=key)
|
||||
second = send(self.alice, self.chat, "Привет 👋", key=key)
|
||||
self.assertEqual((first[0], second[0]), (201, 201))
|
||||
self.assertEqual(first[1], second[1])
|
||||
|
||||
def test_key_order_in_json_does_not_matter(self):
|
||||
key = new_key()
|
||||
headers = {"Idempotency-Key": key}
|
||||
first = call("POST", self.path, {"text": "порядок"}, user=self.alice, headers=headers)
|
||||
second = call("POST", self.path, raw=' { "text" : "порядок" } '.encode(), user=self.alice, headers=headers)
|
||||
self.assertEqual(first[1], second[1])
|
||||
|
||||
def test_other_text_with_same_key_is_409(self):
|
||||
key = new_key()
|
||||
first = send(self.alice, self.chat, "первый текст", key=key)
|
||||
status, body, _ = send(self.alice, self.chat, "другой текст", key=key)
|
||||
self.assertEqual(status, 409)
|
||||
self.assertEqual(body["error"]["code"], "conflict")
|
||||
# конфликт ничего не меняет: исходный текст по-прежнему возвращается
|
||||
self.assertEqual(send(self.alice, self.chat, "первый текст", key=key)[1], first[1])
|
||||
|
||||
def test_same_key_for_other_user_and_other_chat(self):
|
||||
key = new_key()
|
||||
other_chat = new_chat(self.alice)
|
||||
first = send(self.alice, self.chat, "общий ключ", key=key)[1]
|
||||
by_bob = send(self.bob, self.chat, "общий ключ", key=key)[1]
|
||||
in_other_chat = send(self.alice, other_chat, "общий ключ", key=key)[1]
|
||||
self.assertEqual(len({first["id"], by_bob["id"], in_other_chat["id"]}), 3)
|
||||
self.assertEqual(by_bob["sender_id"], self.bob["id"])
|
||||
|
||||
def test_repeat_checks_access_again(self):
|
||||
key = new_key()
|
||||
send(self.alice, self.chat, "только участникам", key=key)
|
||||
self.assertEqual(send(self.eve, self.chat, "только участникам", key=key)[0], 404)
|
||||
self.assertEqual(send({"token": "x" * 43}, self.chat, "только участникам", key=key)[0], 401)
|
||||
|
||||
def test_invalid_body_does_not_take_key(self):
|
||||
key = new_key()
|
||||
self.assertEqual(send(self.alice, self.chat, "", key=key)[0], 400)
|
||||
self.assertEqual(send(self.alice, self.chat, "теперь верно", key=key)[0], 201)
|
||||
|
||||
def test_parallel_repeat_through_different_replicas(self):
|
||||
user = new_user("idem")
|
||||
chat = new_chat(user)
|
||||
instances = set()
|
||||
for round_number in range(10):
|
||||
key = new_key()
|
||||
barrier = threading.Barrier(8)
|
||||
|
||||
def post(_):
|
||||
barrier.wait()
|
||||
return send(user, chat, "сообщение %d" % round_number, key=key)
|
||||
|
||||
with ThreadPoolExecutor(max_workers=8) as pool:
|
||||
results = list(pool.map(post, range(8)))
|
||||
self.assertEqual({status for status, _, _ in results}, {201})
|
||||
self.assertEqual(len({message["id"] for _, message, _ in results}), 1)
|
||||
instances |= {headers["X-Instance-Id"] for _, _, headers in results}
|
||||
self.assertGreaterEqual(len(instances), 2, "запросы не дошли до разных реплик")
|
||||
items, _ = history(user, chat, 100)
|
||||
self.assertEqual(len(items), 10)
|
||||
print("\n10 ключей по 8 параллельных запросов: реплик %d, сообщений в истории %d" % (len(instances), len(items)))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,145 @@
|
||||
import base64
|
||||
import json
|
||||
import unittest
|
||||
import urllib.parse
|
||||
|
||||
from api import call, history, new_chat, new_user, send
|
||||
|
||||
|
||||
class MessagePaginationTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.user = new_user()
|
||||
cls.chat = new_chat(cls.user)
|
||||
cls.sent = [send(cls.user, cls.chat, "сообщение %d" % number)[1] for number in range(25)]
|
||||
cls.path = "/api/v1/chats/" + cls.chat["id"] + "/messages"
|
||||
|
||||
def test_walk_several_pages(self):
|
||||
items, sizes = history(self.user, self.chat, limit=10)
|
||||
self.assertEqual(sizes, [10, 10, 5])
|
||||
self.assertEqual(items, self.sent)
|
||||
|
||||
def test_no_duplicates_and_order(self):
|
||||
items, _ = history(self.user, self.chat, limit=7)
|
||||
ids = [item["id"] for item in items]
|
||||
self.assertEqual(len(ids), len(set(ids)))
|
||||
keys = [(item["created_at"], item["id"]) for item in items]
|
||||
self.assertEqual(keys, sorted(keys))
|
||||
|
||||
def test_exact_page_has_no_cursor(self):
|
||||
_, page, _ = call("GET", self.path + "?limit=25", user=self.user)
|
||||
self.assertEqual(len(page["items"]), 25)
|
||||
self.assertIsNone(page["next_cursor"])
|
||||
|
||||
def test_default_limit(self):
|
||||
_, page, _ = call("GET", self.path, user=self.user)
|
||||
self.assertEqual(len(page["items"]), 25)
|
||||
|
||||
def test_limit_can_change_between_pages(self):
|
||||
_, first, _ = call("GET", self.path + "?limit=3", user=self.user)
|
||||
cursor = urllib.parse.quote(first["next_cursor"], safe="")
|
||||
_, second, _ = call("GET", self.path + "?limit=100&cursor=" + cursor, user=self.user)
|
||||
self.assertEqual(first["items"] + second["items"], self.sent)
|
||||
|
||||
def test_bad_limit(self):
|
||||
for limit in ("0", "101", "-1", "abc", "1.5", ""):
|
||||
with self.subTest(limit=limit):
|
||||
self.assertEqual(call("GET", self.path + "?limit=" + limit, user=self.user)[0], 400)
|
||||
|
||||
def test_bad_cursor(self):
|
||||
for cursor in ("garbage", "", "e30=", "%D0%B9"):
|
||||
with self.subTest(cursor=cursor):
|
||||
self.assertEqual(call("GET", self.path + "?cursor=" + cursor, user=self.user)[0], 400)
|
||||
|
||||
def test_cursor_format_is_checked(self):
|
||||
_, first, _ = call("GET", self.path + "?limit=3", user=self.user)
|
||||
good = first["next_cursor"]
|
||||
scope, created_at, item_id = json.loads(base64.urlsafe_b64decode(good))
|
||||
|
||||
def encode(value, **options):
|
||||
return base64.urlsafe_b64encode(json.dumps(value, **options).encode()).decode()
|
||||
|
||||
# тест знает внутренний формат cursor: собранный заново правильный cursor совпадает с выданным
|
||||
self.assertEqual(encode([scope, created_at, item_id]), good)
|
||||
bad = {
|
||||
"посторонний символ внутри base64": good[:5] + "!" + good[5:],
|
||||
"пробел внутри base64": good[:5] + " " + good[5:],
|
||||
"перевод строки в конце": good + "\n",
|
||||
"лишний знак =": good + "=",
|
||||
"обрезанный": good[:-4],
|
||||
"время не в формате сервера": encode([scope, "вчера", item_id]),
|
||||
"время без микросекунд": encode([scope, created_at[:19] + "Z", item_id]),
|
||||
"время с неполными микросекундами": encode([scope, created_at[:21] + "Z", item_id]),
|
||||
"время со смещением вместо Z": encode([scope, created_at[:-1] + "+00:00", item_id]),
|
||||
"несуществующая дата": encode([scope, "2026-13-45T25:61:61.000000Z", item_id]),
|
||||
"число вместо времени": encode([scope, 1234567890, item_id]),
|
||||
"id не UUID": encode([scope, created_at, "abc"]),
|
||||
"UUID в верхнем регистре": encode([scope, created_at, item_id.upper()]),
|
||||
"UUID без дефисов": encode([scope, created_at, item_id.replace("-", "")]),
|
||||
"null вместо id": encode([scope, created_at, None]),
|
||||
"лишний элемент": encode([scope, created_at, item_id, "x"]),
|
||||
"не хватает элемента": encode([scope, created_at]),
|
||||
"объект вместо списка": encode({"scope": scope, "created_at": created_at, "id": item_id}),
|
||||
"тот же JSON без пробелов": encode([scope, created_at, item_id], separators=(",", ":")),
|
||||
"пустой список": encode([]),
|
||||
}
|
||||
for name, cursor in bad.items():
|
||||
with self.subTest(name):
|
||||
path = self.path + "?cursor=" + urllib.parse.quote(cursor, safe="")
|
||||
status, body, _ = call("GET", path, user=self.user)
|
||||
self.assertEqual(status, 400)
|
||||
self.assertEqual(body["error"]["code"], "invalid_request")
|
||||
# правильный cursor при этом продолжает работать
|
||||
self.assertEqual(call("GET", self.path + "?cursor=" + urllib.parse.quote(good, safe=""), user=self.user)[0], 200)
|
||||
|
||||
def test_cursor_from_another_chat(self):
|
||||
other = new_chat(self.user, title="Другой чат")
|
||||
send(self.user, other, "раз")
|
||||
send(self.user, other, "два")
|
||||
_, page, _ = call("GET", "/api/v1/chats/" + other["id"] + "/messages?limit=1", user=self.user)
|
||||
cursor = urllib.parse.quote(page["next_cursor"], safe="")
|
||||
self.assertEqual(call("GET", self.path + "?cursor=" + cursor, user=self.user)[0], 400)
|
||||
|
||||
def test_new_message_appears_after_last_page(self):
|
||||
user = new_user()
|
||||
chat = new_chat(user)
|
||||
send(user, chat, "раз")
|
||||
send(user, chat, "два")
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
_, first, _ = call("GET", path + "?limit=1", user=user)
|
||||
_, created, _ = send(user, chat, "три")
|
||||
cursor = urllib.parse.quote(first["next_cursor"], safe="")
|
||||
_, rest, _ = call("GET", path + "?limit=100&cursor=" + cursor, user=user)
|
||||
self.assertEqual([item["text"] for item in rest["items"]], ["два", "три"])
|
||||
self.assertEqual(rest["items"][-1], created)
|
||||
|
||||
|
||||
class ChatPaginationTest(unittest.TestCase):
|
||||
def test_walk_chat_list(self):
|
||||
user = new_user()
|
||||
created = [new_chat(user, title="Чат %d" % number) for number in range(5)]
|
||||
items, cursor = [], None
|
||||
while True:
|
||||
path = "/api/v1/chats?limit=2"
|
||||
if cursor:
|
||||
path += "&cursor=" + urllib.parse.quote(cursor, safe="")
|
||||
status, page, _ = call("GET", path, user=user)
|
||||
self.assertEqual(status, 200)
|
||||
self.assertLessEqual(len(page["items"]), 2)
|
||||
items += page["items"]
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
self.assertEqual(items, created)
|
||||
|
||||
def test_chat_cursor_belongs_to_user(self):
|
||||
alice, bob = new_user("alice"), new_user("bob")
|
||||
for number in range(2):
|
||||
new_chat(alice, bob, title="Общий %d" % number)
|
||||
_, page, _ = call("GET", "/api/v1/chats?limit=1", user=alice)
|
||||
cursor = urllib.parse.quote(page["next_cursor"], safe="")
|
||||
self.assertEqual(call("GET", "/api/v1/chats?cursor=" + cursor, user=bob)[0], 400)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,153 @@
|
||||
import unittest
|
||||
|
||||
from api import call, login, new_chat, new_key, new_user, send, user_body
|
||||
|
||||
|
||||
class ErrorFormatTest(unittest.TestCase):
|
||||
def assert_error(self, result, status, code):
|
||||
got_status, body, headers = result
|
||||
self.assertEqual(got_status, status)
|
||||
self.assertEqual(set(body), {"error"})
|
||||
self.assertEqual(set(body["error"]), {"code", "message", "request_id"})
|
||||
self.assertEqual(body["error"]["code"], code)
|
||||
self.assertTrue(body["error"]["message"])
|
||||
self.assertEqual(body["error"]["request_id"], headers["X-Request-Id"])
|
||||
|
||||
|
||||
class InvalidJsonTest(ErrorFormatTest):
|
||||
def test_malformed_json(self):
|
||||
self.assert_error(call("POST", "/api/v1/users", raw=b'{"username": "abc", '), 400, "invalid_request")
|
||||
|
||||
def test_not_an_object(self):
|
||||
self.assert_error(call("POST", "/api/v1/users", raw=b'["abc"]'), 400, "invalid_request")
|
||||
|
||||
def test_extra_field(self):
|
||||
self.assert_error(call("POST", "/api/v1/users", user_body(is_admin=True)), 400, "invalid_request")
|
||||
|
||||
def test_wrong_type(self):
|
||||
self.assert_error(call("POST", "/api/v1/users", user_body(username=12345)), 400, "invalid_request")
|
||||
|
||||
def test_missing_field(self):
|
||||
body = user_body()
|
||||
del body["password"]
|
||||
self.assert_error(call("POST", "/api/v1/users", body), 400, "invalid_request")
|
||||
|
||||
def test_malformed_json_in_message(self):
|
||||
user = new_user()
|
||||
chat = new_chat(user)
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
headers = {"Idempotency-Key": new_key()}
|
||||
self.assert_error(call("POST", path, raw=b"{text: no quotes}", user=user, headers=headers), 400, "invalid_request")
|
||||
|
||||
def test_only_utf8_is_accepted(self):
|
||||
user = new_user()
|
||||
chat = new_chat(user)
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
text = '{"text": "привет"}'
|
||||
for raw in (text.encode("utf-16"), text.encode("utf-32"), b"\xef\xbb\xbf" + text.encode(), text.encode("cp1251")):
|
||||
with self.subTest(start=raw[:4]):
|
||||
headers = {"Idempotency-Key": new_key()}
|
||||
self.assert_error(call("POST", path, raw=raw, user=user, headers=headers), 400, "invalid_request")
|
||||
|
||||
def test_content_type_must_be_json(self):
|
||||
body = str(user_body()).replace("'", '"').encode()
|
||||
for content_type in ("text/plain", "application/xml"):
|
||||
with self.subTest(content_type=content_type):
|
||||
headers = {"Content-Type": content_type}
|
||||
self.assert_error(call("POST", "/api/v1/users", raw=body, headers=headers), 400, "invalid_request")
|
||||
|
||||
def test_too_large_json(self):
|
||||
body = b'{"username": "' + b"x" * (2 * 1024 * 1024) + b'"}'
|
||||
self.assert_error(call("POST", "/api/v1/users", raw=body), 413, "payload_too_large")
|
||||
|
||||
def test_deeply_nested_json(self):
|
||||
self.assert_error(call("POST", "/api/v1/users", raw=b"[" * 100000), 400, "invalid_request")
|
||||
|
||||
def test_broken_json_without_token_is_401(self):
|
||||
# сначала проверяется токен, и только потом разбирается тело
|
||||
status, _, _ = call("POST", "/api/v1/chats", raw=b"{broken")
|
||||
self.assertEqual(status, 401)
|
||||
|
||||
|
||||
class UserValidationTest(ErrorFormatTest):
|
||||
def test_bad_usernames(self):
|
||||
for username in ("ab", "a" * 33, "Alice", "with space", "имя", "abc\n", ""):
|
||||
with self.subTest(username=username):
|
||||
self.assert_error(call("POST", "/api/v1/users", user_body(username=username)), 400, "invalid_request")
|
||||
|
||||
def test_bad_display_names(self):
|
||||
for display_name in ("", " ", "\t\n", "я" * 101, "имя\u0000"):
|
||||
with self.subTest(display_name=display_name):
|
||||
result = call("POST", "/api/v1/users", user_body(display_name=display_name))
|
||||
self.assert_error(result, 400, "invalid_request")
|
||||
|
||||
def test_display_name_length_is_counted_in_code_points(self):
|
||||
# 100 эмодзи это 400 байт в UTF-8, но ровно 100 code points
|
||||
status, user, _ = call("POST", "/api/v1/users", user_body(display_name="🙂" * 100))
|
||||
self.assertEqual(status, 201)
|
||||
self.assertEqual(user["display_name"], "🙂" * 100)
|
||||
|
||||
def test_bad_passwords(self):
|
||||
for password in ("short-11-ch", "x" * 129, " " * 12, "", 123456789012, None):
|
||||
with self.subTest(password=password):
|
||||
self.assert_error(call("POST", "/api/v1/users", user_body(password=password)), 400, "invalid_request")
|
||||
|
||||
def test_password_length_limits(self):
|
||||
for password in ("exactly-12-c", "x" * 128, "пароль🙂пароль"):
|
||||
with self.subTest(length=len(password)):
|
||||
body = user_body(password=password)
|
||||
self.assertEqual(call("POST", "/api/v1/users", body)[0], 201)
|
||||
self.assertEqual(login(body["username"], password)[0], 201)
|
||||
|
||||
def test_password_is_never_returned(self):
|
||||
body = user_body()
|
||||
status, user, _ = call("POST", "/api/v1/users", body)
|
||||
self.assertEqual(status, 201)
|
||||
self.assertEqual(set(user), {"id", "username", "display_name", "created_at"})
|
||||
_, session, _ = login(body["username"], body["password"])
|
||||
self.assertNotIn(body["password"], str(session))
|
||||
|
||||
def test_duplicate_username(self):
|
||||
body = user_body(display_name="Первый")
|
||||
self.assertEqual(call("POST", "/api/v1/users", body)[0], 201)
|
||||
body["display_name"] = "Второй"
|
||||
self.assert_error(call("POST", "/api/v1/users", body), 409, "conflict")
|
||||
|
||||
|
||||
class MessageValidationTest(ErrorFormatTest):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.user = new_user()
|
||||
cls.chat = new_chat(cls.user)
|
||||
|
||||
def test_empty_message(self):
|
||||
self.assert_error(send(self.user, self.chat, ""), 400, "invalid_request")
|
||||
|
||||
def test_whitespace_message(self):
|
||||
for text in (" ", " \n\t ", " "):
|
||||
with self.subTest(text=repr(text)):
|
||||
self.assert_error(send(self.user, self.chat, text), 400, "invalid_request")
|
||||
|
||||
def test_nul_character(self):
|
||||
self.assert_error(send(self.user, self.chat, "до\u0000после"), 400, "invalid_request")
|
||||
|
||||
def test_text_limit(self):
|
||||
self.assertEqual(send(self.user, self.chat, "ы" * 4000)[0], 201)
|
||||
self.assert_error(send(self.user, self.chat, "ы" * 4001), 400, "invalid_request")
|
||||
|
||||
def test_sender_id_is_not_accepted(self):
|
||||
path = "/api/v1/chats/" + self.chat["id"] + "/messages"
|
||||
body = {"text": "привет", "sender_id": self.user["id"]}
|
||||
headers = {"Idempotency-Key": new_key()}
|
||||
self.assert_error(call("POST", path, body, user=self.user, headers=headers), 400, "invalid_request")
|
||||
|
||||
def test_unicode_is_kept(self):
|
||||
text = "Привет 👋 你好 مرحبا\nвторая строка"
|
||||
status, message, _ = send(self.user, self.chat, text)
|
||||
self.assertEqual(status, 201)
|
||||
self.assertEqual(message["text"], text)
|
||||
self.assertEqual(message["sender_id"], self.user["id"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user