77 changed files with 6565 additions and 16 deletions
+16
View File
@@ -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
View File
@@ -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
View File
@@ -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"]
+62 -1
View File
@@ -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'
+267 -14
View File
@@ -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 не запускалось. Генератор нагрузки работал на том же компьютере, замеры дают порядок величин, а не предел стенда.
+14
View File
@@ -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
View File
@@ -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
+81
View File
@@ -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.
+14
View File
@@ -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
+67
View File
@@ -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
+143
View File
@@ -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
+63
View File
@@ -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
пробная запись прошла
+88
View File
@@ -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
+10
View File
@@ -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: подтверждённые сообщения на месте, дублей нет
+16
View File
@@ -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
+43
View File
@@ -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, после очистки расхождений нет
+55
View File
@@ -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
+93
View File
@@ -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 секретов нет
(пусто)
+12
View File
@@ -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 секунд
+128
View File
@@ -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)
+54
View File
@@ -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
}
}
]
}
+35
View File
@@ -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
}
}
]
}
+99
View File
@@ -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
}
}
}
]
}
+7
View File
@@ -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"]
+8
View File
@@ -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"}}
+8
View File
@@ -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"}}
+8
View File
@@ -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"}}
+8
View File
@@ -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"}}
+71
View File
@@ -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
+5
View File
@@ -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"]
+35
View File
@@ -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
+39
View File
@@ -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);
+12
View File
@@ -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)
);
+31
View File
@@ -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)
);
+32
View File
@@ -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
+23
View File
@@ -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)
+245
View File
@@ -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()
+11
View File
@@ -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
+56
View File
@@ -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;
+32
View File
@@ -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"
+14
View File
@@ -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
+38
View File
@@ -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 ' ')"
+26
View File
@@ -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;
+82
View File
@@ -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()
+14
View File
@@ -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"
+120
View File
@@ -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()
+12
View File
@@ -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
+68
View File
@@ -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")
+38
View File
@@ -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)
+11
View File
@@ -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
View File
@@ -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
+93
View File
@@ -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
View File
@@ -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,
)
+48
View File
@@ -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()
+46
View File
@@ -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", [])
+41
View File
@@ -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()
+55
View File
@@ -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
+45
View File
@@ -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()
+47
View File
@@ -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
View File
@@ -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
+102
View File
@@ -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
+49
View File
@@ -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()
+75
View File
@@ -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()
+263
View File
@@ -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()
+177
View File
@@ -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()
+288
View File
@@ -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()
+103
View File
@@ -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
+85
View File
@@ -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()
+320
View File
@@ -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, "photo‮gnp.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()
+144
View File
@@ -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()
+94
View File
@@ -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()
+63
View File
@@ -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()
+98
View File
@@ -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()
+145
View File
@@ -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()
+153
View File
@@ -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()