1 Commits
33 changed files with 3111 additions and 45 deletions
+7 -11
View File
@@ -1,20 +1,16 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# Скопировать в .env. Секреты сюда не класть: их создаёт scripts/bootstrap.py в secrets/.
# APP_PORT — порт балансировщика на localhost. Реплики API наружу не публикуются.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
SESSION_STORE=redis
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=http://s3:9000
S3_REGION=us-east-1
POOL_MAX=10
S3_ENDPOINT=minio:9000
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=10485760
MAX_IMAGE_PIXELS=40000000
S3_SECURE=false
RECONCILE_GRACE_SECONDS=120
+4
View File
@@ -0,0 +1,4 @@
*.sh text eol=lf
*.cfg text eol=lf
Dockerfile text eol=lf
*.sql text eol=lf
+14 -14
View File
@@ -1,18 +1,18 @@
## Лабораторная 4
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Автор / группа: Орлова Владислава, БПИ2301
Целевая оценка (3/4/5): 5
Трек 5, если заявлен: трек 2, сверка PostgreSQL и объектов MinIO
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
Что реализовано и что перенесено: перенесён стенд лабораторной 3 (две реплики API, HAProxy, Redis-сессии, идемпотентность сообщений). Добавлены приватный bucket MinIO, загрузка и скачивание PNG/JPEG через API, метаданные в PostgreSQL. Образ `pgsty/minio` с digest `sha256:b6bfe7239bfc83fb90d31612d9704d86039dd714f7904b3f1ad68f211e602372`, потому что официальный `minio/minio` с Docker Hub и Quay без логина больше не скачивается. Версия сервера внутри образа: RELEASE.2026-08-04.
Команды запуска из чистого clone: `python -X utf8 scripts/bootstrap.py`, затем `docker compose --env-file .env up -d --build --scale api=2`. Программы make в Windows нет, поэтому check и smoke запущены командами из Makefile напрямую.
Результаты проверок и ссылка на REPORT.md: smoke PASS, persistence PASS, три failover PASS (1 ошибка на прогон, восстановление 0,669 с, 1,276 с и 0,745 с). Негативные файлы и десять загрузок PASS, пик памяти 105,7 МиБ из 256. Чужой запрос к bucket получил 403. Трек 2: сухой прогон, применение, пустой второй прогон, свежий файл и файл из сообщения сохранены. Подробности в REPORT.md и evidence/.
Ограничения / известные ошибки: один Postgres, один Redis, один MinIO и один балансировщик. Остановка одной API переживается. Выключение компьютера и отказ диска нет. Прямой upload по временной ссылке не делался. Сверка не восстанавливает байты, если на файл уже ссылается сообщение, а объекта нет.
Источники и использование ИИ: задание курса и контракт. Код и отчёт собраны в Cursor. Секреты в репозиторий не входят.
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [x] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод. Программы make в Windows нет. Те же команды выполнены: `python -X utf8 scripts/check_contract.py` и `python -X utf8 tests/smoke.py --base-url http://127.0.0.1:8080`. Обе напечатали PASS.
- [x] Сценарии отказов/безопасности своего уровня воспроизведены.
- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
+27
View File
@@ -0,0 +1,27 @@
FROM python:3.12.10-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PYTHONPATH=/app/src \
APP_HOST=0.0.0.0 \
APP_PORT=8080
WORKDIR /app
RUN useradd --uid 10001 --create-home --shell /usr/sbin/nologin app
COPY requirements.txt /app/requirements.txt
RUN pip install --no-cache-dir --upgrade pip==25.0.1 \
&& pip install --no-cache-dir -r /app/requirements.txt
COPY migrations /app/migrations
COPY src /app/src
USER 10001
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=25s --retries=8 \
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"
CMD ["python", "/app/src/main.py"]
+87 -20
View File
@@ -1,37 +1,104 @@
# Отчёт — лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Орлова Владислава, БПИ2301
- Целевая оценка: 5. Трек 2, сверка PostgreSQL и объектов в bucket
- Commit/PR: ещё не публиковала
- Источники и помощь: задание и контракт этой лабораторной, перенесённый стенд лабораторной 3, документация MinIO по приватному bucket и отдельному пользователю. Код и отчёт я собирала в Cursor. Числа ниже сняты с моего запуска, я их не округляла «для красоты»
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker Engine и Python 3.9+. У меня Docker Engine 26.1.4 и Python на Windows. Программы `make` в системе нет, поэтому я запускала те же команды, которые написаны в Makefile, через `python -X utf8`. Флаг нужен, чтобы Windows не читала JSON в кодировке cp1251.
```sh
python -X utf8 scripts/bootstrap.py
docker compose --env-file .env up -d --build --scale api=2
python -X utf8 scripts/wait_ready.py
python -X utf8 scripts/check_contract.py
python -X utf8 tests/smoke.py --base-url http://127.0.0.1:8080
```
`bootstrap.py` один раз создаёт `secrets/` и `.env`. Пароли в консоль не печатаются. Повторный запуск уже созданные файлы не перезаписывает. В git эти файлы не входят.
Остановить стенд, не удаляя данные: `docker compose --env-file .env stop`. Удалить учебные данные вместе с volume: `docker compose --env-file .env down -v`. Вторую команду я использую только когда хочу чистую базу.
Образы, которые реально поднимаются:
| Роль | Образ |
| --- | --- |
| API | свой Dockerfile, база `python:3.12.10-slim-bookworm` |
| Postgres | `postgres:16.10-bookworm` |
| Redis | `redis:7.4.2-bookworm` |
| Балансировщик | `haproxy:2.8.14` |
| MinIO и клиент mc | `pgsty/minio@sha256:b6bfe7239bfc83fb90d31612d9704d86039dd714f7904b3f1ad68f211e602372` |
Сервер внутри этого образа отвечает `minio version RELEASE.2026-08-04T00-00-00Z`, клиент mc той же даты. Официальный `minio/minio` с Docker Hub в сентябре 2026 перестал скачиваться, а `quay.io/minio/minio` без логина отвечает `unauthorized`. Поэтому стенд закреплён на публичном образе `pgsty/minio` с digest, который я скачала и проверила. Это сервер MinIO с тем же протоколом S3, отдельный продукт я не подменяла.
Лимиты по умолчанию: две реплики API по 0,50 CPU и 256 МиБ, Postgres 1,00 CPU и 512 МиБ, Redis 0,25 CPU и 128 МиБ, HAProxy 0,25 CPU и 128 МиБ, MinIO 0,50 CPU и 512 МиБ. Наружу открыт только `127.0.0.1:8080` у балансировщика.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Клиент ходит в HAProxy. HAProxy по кругу отправляет запрос на одну из двух реплик API. Сессии лежат в Redis, сообщения и метаданные файлов в PostgreSQL. Сами байты картинки лежат в приватном bucket `messenger-attachments`. Локального каталога с файлами у API нет.
Из лабораторной 3 я перенесла регистрацию, сессии, чаты, ленту сообщений, идемпотентность POST сообщения, две реплики и остановку одной реплики. Схема ждёт версию `003_attachments`. Миграции по-прежнему применяет отдельный контейнер `migrate`, реплики API сами таблицы не создают.
Вложение создаётся так. Сначала проверяется сессия и участие в чате. Потом имя файла: это только подпись, в ключе объекта его нет. Ключ назначает сервер, он выглядит как `chats/<chat_id>/attachments/<id>/original`. Тело читается не дальше 10 МиБ плюс один байт. Если байт лишний, ответ 413 и картинка не декодируется. Тип определяется по сигнатуре PNG или JPEG и сравнивается с заголовком Content-Type. Размер в пикселях читается из заголовка файла до полной распаковки. Больше 40 миллионов пикселей даёт 413. Pillow распаковывает файл только после этой проверки, и у него стоит тот же предел пикселей. Повреждённый файл и подмена типа дают 415.
Ответ 201 со `status=ready` уходит после двух записей: объект уже лежит в bucket, строка уже лежит в `attachments`. Если вставка в базу не прошла, API удаляет объект. Если и удаление не прошло, объект остаётся без строки. Его забирает сверка, и только когда объекту больше `RECONCILE_GRACE_SECONDS`. Сейчас это 120 секунд. Свежий файл сверка не трогает: загрузка могла записать байты раньше, чем строку.
Пустой текст у сообщения разрешён, когда есть хотя бы одно вложение. Текст из одних пробелов по-прежнему 400. Чужое или неизвестное вложение в сообщении даёт 404, и ключ идемпотентности при этом не занимается. Повтор того же ключа с тем же текстом и теми же `attachment_ids` возвращает то же сообщение. Другой текст или другой список файлов при том же ключе даёт 409.
Скачивание идёт через API, без redirect. Участник чата получает байты и настоящий Content-Type. Остальные получают 404 и на метаданные, и на байты. Варианта `thumbnail` в этой работе нет, запрос такого варианта даёт 404.
HAProxy может повторить обычный POST сообщения, потому что у него есть Idempotency-Key. POST вложения он не повторяет: повтор создал бы второй объект. Тело файла балансировщик не складывает целиком в свой буфер. Буфер остаётся 64 КиБ, таймаут клиента и сервера для загрузки поднят до 60 секунд.
Bucket создаёт контейнер `minio-init`. Повторный запуск делает то же самое и заканчивается успешно: bucket уже есть, пользователь API уже есть, политика записывается заново. Политика разрешает этому пользователю только `GetBucketLocation`, `ListBucket`, `GetObject`, `PutObject` и `DeleteObject` в одном bucket. Корневой пароль MinIO есть у контейнеров `minio` и `minio-init`. В API он не смонтирован. Консоль слушает `127.0.0.1:9001` внутри контейнера MinIO, в сеть стенда и на хост она не открыта.
Готовность `/health/ready` проверяет миграцию `003_attachments`, Redis и доступность bucket. `/health/live` проверяет только процесс.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
Машина: Intel Core i5-10300H, 8 логических процессоров, 17008717824 байт памяти. Дата прогона 12 ноября 2026.
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Критерий | Команда и что я увидела | Файл |
| --- | --- | --- |
| Контракт на диске | `python -X utf8 scripts/check_contract.py` напечатал PASS. Это проверка файлов, сервер она не запускает | вывод в этом разделе |
| Публичный smoke | `python -X utf8 tests/smoke.py --base-url http://127.0.0.1:8080` напечатал `PASS: lab4 public API scenario` | — |
| Файл переживает рестарт хранилищ | `tests/resilience.py --mode persistence`, hook `scripts/restart.sh`. PASS. Старый токен подошёл, байты PNG совпали. StartedAt изменился у postgres, redis, minio и обеих API. У балансировщика не изменился | `evidence/persistence.txt` |
| Остановка одной реплики | Три прогона `tests/resilience.py --mode failover`, hook `scripts/stop-one.sh`. До остановки были видны 2 реплики. Ошибок за прогон: 1, 1 и 1. Успешных записей: 136, 130 и 136. Восстановление: 0,669 с, 1,276 с и 0,745 с. Остановленный контейнер вышел с кодом 143. Тест после этого скачал тот же PNG | `evidence/failover.txt` |
| Большой, битый, чужой файл | `python -X utf8 student-tests/run_files.py`. Файл больше 10 МиБ и заголовок 8000×8000 дают 413. Битый PNG и PNG с заголовком image/jpeg дают 415. Имя с `/`, `\` или переводом строки даёт 400. Чужой чат, неизвестный id и посторонний пользователь дают 404. Без токена 401. Эти ответы не были 500 | `evidence/files.json` |
| Десять загрузок и память | Тот же скрипт, десять PNG по 922428 байт, картинка 640×480. Выше всего `docker stats` показал 105,7 МиБ и 103,9 МиБ при лимите 256 МиБ. Процесс не упал | `evidence/files.json` |
| Закрытый bucket | Чужой контейнер без пароля получил 403 на bucket. Консоль по сети не открылась. На API нет файла картинки | `evidence/private.txt` |
| Трек 2 | `docker compose --env-file .env exec -T api python /app/src/track2_demo.py` | `evidence/track2.json` |
## Эксперименты и отказы
Публичные файлы в `contracts/` и `tests/` я не меняла.
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
## Трек 2
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
Гипотеза: если объект в bucket и строка в PostgreSQL разошлись, отдельный проход может убрать только старый мусор. Файл, которому меньше 120 секунд, и файл, на который уже ссылается сообщение, остаются.
## Ограничения и следующие шаги
Как я ломала данные специально. Загрузила четыре картинки. Первая прикреплена к сообщению, объект на месте. Вторая ни к чему не прикреплена и только что загружена. У третьей я сдвинула `created_at` на два часа назад и удалила объект. Четвёртая тоже прикреплена к сообщению, её дату я тоже состарила и объект удалила. Рядом положила два объекта без строк: один с меткой времени двухчасовой давности, другой с текущей меткой.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Сухой прогон напечатал два удаления: старый объект без строки и старую строку без объекта. Применение удалило 1 объект и 1 строку. Второй прогон напечатал пустой список удалений. Картинка из сообщения скачалась байт в байт. Свежая неприкреплённая картинка тоже. Свежий объект без строки остался. Строка, на которую ссылается сообщение, осталась, хотя файла уже нет: её метаданные читаются, а скачивание байтов даёт 404, не 500.
Обход увидел 33 объекта и 33 строки и потратил на список 0,091144 секунды. Для каждого объекта сверка ещё делает `stat`, поэтому на тысячах файлов это будет дольше. Тысячи файлов я не гоняла.
Команды сверки самой по себе, без учебного сценария:
```sh
docker compose --env-file .env exec -T api python /app/src/reconcile.py
docker compose --env-file .env exec -T api python /app/src/reconcile.py --apply
```
Первая только печатает план. Вторая удаляет то, что план разрешил.
## Ограничения
Стенд переживает остановку одной реплики API и рестарт Postgres, Redis и MinIO, если volume на месте. Выключение компьютера и поломка диска данные не сохраняют. Балансировщик, Postgres и MinIO в стенде по одному экземпляру: их отказ останавливает сервис.
Прямую загрузку по временной ссылке я не добавляла. Обязательный путь через API остаётся единственным.
Память я снимала командой `docker stats`. Это редкие замеры контейнера, не пик аллокаций внутри Python. В окне десяти загрузок выше 105,7 МиБ выборка не поднялась. Одна загрузка ограничена 10 МиБ на чтение и 40 миллионами пикселей до распаковки, но десять больших фотографий одновременно могут подойти к лимиту 256 МиБ ближе, чем мои картинки 640×480.
Сверка не чинит файл, который уже указан в сообщении, если байтов в bucket нет. Она оставляет строку, чтобы сообщение не потеряло ссылку. Восстановить сами байты ей неоткуда.
Образ `pgsty/minio` я выбрала, потому что официальный образ MinIO больше не скачивается без логина. Digest закреплён. Новые уязвимости этого выпуска я отдельно не проверяла.
+216
View File
@@ -0,0 +1,216 @@
name: mtusi-lab4
services:
postgres:
image: postgres:16.10-bookworm
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
command:
- postgres
- -c
- fsync=on
- -c
- synchronous_commit=on
- -c
- full_page_writes=on
- -c
- max_connections=80
- -c
- shared_buffers=64MB
volumes:
- postgres-data:/var/lib/postgresql/data
secrets:
- postgres_password
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 3s
timeout: 3s
retries: 20
start_period: 10s
cpus: "1.00"
mem_limit: 512m
restart: unless-stopped
networks:
- lab
redis:
image: redis:7.4.2-bookworm
command:
- redis-server
- --appendonly
- "yes"
- --appendfsync
- everysec
- --dir
- /data
- --save
- "60"
- "1"
- --bind
- 0.0.0.0
- --protected-mode
- "no"
volumes:
- redis-data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 3s
timeout: 3s
retries: 20
start_period: 5s
cpus: "0.25"
mem_limit: 128m
restart: unless-stopped
networks:
- lab
minio:
image: pgsty/minio@sha256:b6bfe7239bfc83fb90d31612d9704d86039dd714f7904b3f1ad68f211e602372
command: ["server", "/data", "--console-address", "127.0.0.1:9001"]
environment:
MINIO_ROOT_USER_FILE: /run/secrets/minio_root_user
MINIO_ROOT_PASSWORD_FILE: /run/secrets/minio_root_password
volumes:
- minio-data:/data
secrets:
- minio_root_user
- minio_root_password
healthcheck:
test: ["CMD", "curl", "-f", "http://127.0.0.1:9000/minio/health/live"]
interval: 3s
timeout: 3s
retries: 20
start_period: 8s
cpus: "0.50"
mem_limit: 512m
restart: unless-stopped
networks:
- lab
minio-init:
image: pgsty/minio@sha256:b6bfe7239bfc83fb90d31612d9704d86039dd714f7904b3f1ad68f211e602372
entrypoint: ["/bin/sh", "/init/minio-init.sh"]
volumes:
- ./scripts/minio-init.sh:/init/minio-init.sh:ro
- ./infra/minio-api-policy.json:/init/policy.json:ro
secrets:
- minio_root_user
- minio_root_password
- s3_access_key
- s3_secret_key
depends_on:
minio:
condition: service_healthy
restart: "no"
networks:
- lab
migrate:
build: .
image: mtusi-lab4-api:local
command: ["python", "/app/src/migrate.py"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets:
- database_url
depends_on:
postgres:
condition: service_healthy
healthcheck:
disable: true
cpus: "0.50"
mem_limit: 256m
restart: "no"
networks:
- lab
api:
build: .
image: mtusi-lab4-api:local
environment:
APP_HOST: 0.0.0.0
APP_PORT: "8080"
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: redis
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
POOL_MAX: ${POOL_MAX:-10}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
S3_ENDPOINT: minio:9000
S3_BUCKET: messenger-attachments
S3_SECURE: "false"
S3_ACCESS_KEY_FILE: /run/secrets/s3_access_key
S3_SECRET_KEY_FILE: /run/secrets/s3_secret_key
RECONCILE_GRACE_SECONDS: ${RECONCILE_GRACE_SECONDS:-120}
secrets:
- database_url
- cache_url
- s3_access_key
- s3_secret_key
depends_on:
migrate:
condition: service_completed_successfully
redis:
condition: service_healthy
minio:
condition: service_healthy
minio-init:
condition: service_completed_successfully
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"]
interval: 5s
timeout: 3s
retries: 8
start_period: 25s
init: true
stop_grace_period: 10s
cpus: "0.50"
mem_limit: 256m
deploy:
replicas: 2
restart: unless-stopped
networks:
- lab
lb:
image: haproxy:2.8.14
volumes:
- ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
ports:
- "127.0.0.1:${APP_PORT:-8080}:8080"
depends_on:
api:
condition: service_healthy
cpus: "0.25"
mem_limit: 128m
restart: unless-stopped
networks:
- lab
networks:
lab:
name: mtusi-lab4-net
volumes:
postgres-data:
redis-data:
minio-data:
secrets:
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
postgres_password:
file: ./secrets/postgres_password
minio_root_user:
file: ./secrets/minio_root_user
minio_root_password:
file: ./secrets/minio_root_password
s3_access_key:
file: ./secrets/s3_access_key
s3_secret_key:
file: ./secrets/s3_secret_key
+8
View File
@@ -0,0 +1,8 @@
Official tests/resilience.py --mode failover, hook scripts/stop-one.sh.
Before each run both API replicas answered. The hook stopped the replica that served the first message and left it stopped. Exit code of that container was 143 (SIGTERM). The public test then read the same PNG bytes through the replica that stayed up.
Run 1: {"observed_instances_before": 2, "successful_writes": 136, "failed_attempts": 1, "first_recovery_seconds": 0.669}
Run 2: {"observed_instances_before": 2, "successful_writes": 130, "failed_attempts": 1, "first_recovery_seconds": 1.276}
Run 3: {"observed_instances_before": 2, "successful_writes": 136, "failed_attempts": 1, "first_recovery_seconds": 0.745}
In all three runs the stopped container was mtusi-lab4-api-2, because that replica served the first message. mtusi-lab4-api-1 stayed up and served the later requests, including the file download. PASS each time.
+22
View File
@@ -0,0 +1,22 @@
{
"concurrent_uploads": 10,
"upload_bytes": 922428,
"image": "640x480 PNG",
"peak_mib": {"mtusi-lab4-api-2": 103.9, "mtusi-lab4-api-1": 105.7},
"limit_mib": 256,
"result": "PASS files",
"also_checked": [
"file bigger than 10485760 bytes -> 413",
"PNG header 8000x8000 -> 413 before decode",
"broken PNG -> 415",
"PNG bytes with Content-Type image/jpeg -> 415",
"filename with slash, backslash or newline -> 400",
"attachment of another chat -> 404",
"unknown attachment id -> 404",
"outsider metadata and bytes -> 404",
"missing thumbnail variant -> 404",
"no token -> 401",
"same Idempotency-Key and same attachment -> same message",
"same key and different text -> 409"
]
}
+13
View File
@@ -0,0 +1,13 @@
Official tests/resilience.py --mode persistence, hook scripts/restart.sh.
The hook restarts postgres, redis, minio and both API replicas. It does not delete volumes and does not load the database again. The balancer is left running.
StartedAt before -> after:
api-1 2026-11-12T07:31:38Z -> 2026-11-12T07:34:43Z
api-2 2026-11-12T07:31:37Z -> 2026-11-12T07:34:43Z
minio 2026-11-12T07:24:33Z -> 2026-11-12T07:34:39Z
postgres 2026-11-12T07:24:33Z -> 2026-11-12T07:34:39Z
redis 2026-11-12T07:24:33Z -> 2026-11-12T07:34:38Z
lb 2026-11-12T07:29:57Z -> unchanged
PASS: persistence preserved confirmed data and existing session.
The same token worked, and the PNG bytes matched the original.
+11
View File
@@ -0,0 +1,11 @@
Published ports: only 127.0.0.1:8080 on the balancer. MinIO 9000 and the console 9001 are not published to the host.
From another container on the network mtusi-lab4-net, without credentials:
GET http://minio:9000/messenger-attachments/ -> 403
GET http://minio:9001/ -> no connection (HTTP code 000). The console listens on 127.0.0.1:9001 inside the MinIO container.
find /app /tmp on an API container found no PNG and no original file. The API service has no volume for files.
The API container receives s3_access_key and s3_secret_key. The MinIO root password is mounted only into minio and minio-init.
minio-init was started again after the bucket already existed and exited 0. Files uploaded earlier were still readable.
+15
View File
@@ -0,0 +1,15 @@
{
"applied_objects": 1,
"applied_rows": 1,
"dry_run_actions": ["delete_orphan_object", "delete_orphan_row"],
"fresh_file_same": true,
"fresh_orphan_kept": true,
"in_use_missing_preserved": true,
"list_seconds": 0.091144,
"objects_seen": 33,
"old_orphan_removed": true,
"preserved_reasons": ["fresh_object", "missing_but_in_use"],
"rows_seen": 33,
"second_run_actions": [],
"used_file_same": true
}
+47
View File
@@ -0,0 +1,47 @@
global
maxconn 256
tune.bufsize 65536
tune.maxrewrite 8192
defaults
mode http
timeout connect 500ms
timeout client 60s
timeout server 60s
timeout http-request 60s
timeout http-keep-alive 2s
timeout queue 2s
timeout check 800ms
option redispatch
option dontlognull
retries 2
retry-on conn-failure empty-response 502 503 504
resolvers docker
nameserver dns 127.0.0.11:53
resolve_retries 3
timeout resolve 1s
timeout retry 1s
hold valid 1s
hold other 1s
hold refused 1s
hold nx 1s
hold timeout 1s
hold obsolete 1s
accepted_payload_size 8192
frontend web
bind *:8080
default_backend api
backend api
balance roundrobin
# Короткий JSON сообщения можно повторить. Загрузку файла не повторяем:
# повтор создал бы второй объект. Тело загрузки не буферизуется целиком.
acl upload method POST path_reg -i ^/api/v1/chats/[0-9a-fA-F-]+/attachments$
http-request wait-for-body time 2s if METH_POST !upload
http-request disable-l7-retry if upload
option httpchk
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host api
http-check expect status 200
server-template api 8 api:8080 check inter 500ms fall 2 rise 2 resolvers docker init-addr none resolve-prefer ipv4 on-marked-down shutdown-sessions
+19
View File
@@ -0,0 +1,19 @@
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": ["arn:aws:s3:::messenger-attachments/*"]
},
{
"Effect": "Allow",
"Action": ["s3:GetBucketLocation", "s3:ListBucket"],
"Resource": ["arn:aws:s3:::messenger-attachments"]
}
]
}
+48
View File
@@ -0,0 +1,48 @@
-- Пользователи, чаты, участники и сообщения.
-- Создание чата в приложении идёт одной транзакцией: строка chats и строки chat_members.
-- Индекс messages_history_idx совпадает с keyset-запросом истории:
-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
-- ORDER BY created_at, id
-- LIMIT $4
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL,
CONSTRAINT users_username_unique UNIQUE (username),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_nonblank CHECK (btrim(display_name) <> ''),
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_at timestamptz NOT NULL,
CONSTRAINT chats_title_nonblank CHECK (btrim(title) <> ''),
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id),
user_id uuid NOT NULL REFERENCES users (id),
ordinal smallint NOT NULL,
PRIMARY KEY (chat_id, user_id),
CONSTRAINT chat_members_ordinal_nonneg CHECK (ordinal >= 0)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats (id),
sender_id uuid NOT NULL REFERENCES users (id),
body text NOT NULL,
created_at timestamptz NOT NULL,
CONSTRAINT messages_body_nonblank CHECK (btrim(body) <> ''),
CONSTRAINT messages_body_len CHECK (char_length(body) BETWEEN 1 AND 4000)
);
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
+19
View File
@@ -0,0 +1,19 @@
-- Результат успешного POST сообщения.
-- Область ключа: пользователь + метод + путь чата + Idempotency-Key.
-- Строка пишется в той же транзакции, что и messages, поэтому 5xx
-- не оставляет «занятый» ключ. Другое тело при живом ключе — отказ
-- на уровне приложения (хеш не совпал), без второй строки messages.
CREATE TABLE idempotency_keys (
user_id uuid NOT NULL REFERENCES users (id),
http_method text NOT NULL,
request_path text NOT NULL,
idem_key text NOT NULL,
request_hash text NOT NULL,
message_id uuid NOT NULL REFERENCES messages (id),
created_at timestamptz NOT NULL,
PRIMARY KEY (user_id, http_method, request_path, idem_key),
CONSTRAINT idempotency_method_post CHECK (http_method = 'POST'),
CONSTRAINT idempotency_key_format CHECK (idem_key ~ '^[A-Za-z0-9._:-]{1,128}$'),
CONSTRAINT idempotency_hash_len CHECK (char_length(request_hash) = 64)
);
+42
View File
@@ -0,0 +1,42 @@
-- Метаданные вложения. Байты лежат в приватном bucket, не в этой таблице.
-- Пустой текст допустим, если к сообщению прикреплено вложение. Пробелы по-прежнему нельзя.
ALTER TABLE messages DROP CONSTRAINT messages_body_nonblank;
ALTER TABLE messages DROP CONSTRAINT messages_body_len;
ALTER TABLE messages
ADD CONSTRAINT messages_body_len CHECK (char_length(body) <= 4000);
ALTER TABLE messages
ADD CONSTRAINT messages_body_nonblank CHECK (body = '' OR btrim(body) <> '');
CREATE TABLE attachments (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats (id),
owner_id uuid NOT NULL REFERENCES users (id),
filename text NOT NULL,
content_type text NOT NULL,
size_bytes bigint NOT NULL,
sha256 text NOT NULL,
object_key text NOT NULL UNIQUE,
status text NOT NULL DEFAULT 'ready',
created_at timestamptz NOT NULL,
updated_at timestamptz NOT NULL,
CONSTRAINT attachments_filename_len CHECK (char_length(filename) BETWEEN 1 AND 255),
CONSTRAINT attachments_content_type_chk CHECK (content_type IN ('image/png', 'image/jpeg')),
CONSTRAINT attachments_size_chk CHECK (size_bytes BETWEEN 1 AND 10485760),
CONSTRAINT attachments_sha_chk CHECK (char_length(sha256) = 64),
CONSTRAINT attachments_status_chk CHECK (status = 'ready'),
CONSTRAINT attachments_key_chk CHECK (char_length(object_key) BETWEEN 1 AND 512)
);
CREATE INDEX attachments_chat_idx ON attachments (chat_id, created_at);
CREATE TABLE message_attachments (
message_id uuid NOT NULL REFERENCES messages (id),
attachment_id uuid NOT NULL REFERENCES attachments (id),
ordinal integer NOT NULL,
PRIMARY KEY (message_id, attachment_id),
UNIQUE (message_id, ordinal),
CONSTRAINT message_attachments_ordinal_chk CHECK (ordinal >= 0 AND ordinal < 10)
);
CREATE INDEX message_attachments_attachment_idx ON message_attachments (attachment_id);
+9
View File
@@ -0,0 +1,9 @@
fastapi==0.115.12
uvicorn[standard]==0.34.2
pydantic==2.11.4
psycopg[binary]==3.2.6
psycopg-pool==3.2.4
redis==5.2.1
argon2-cffi==23.1.0
minio==7.2.15
pillow==11.1.0
+58
View File
@@ -0,0 +1,58 @@
#!/usr/bin/env python3
"""Создать локальные .env и secrets для стенда. Пароль в консоль не печатается."""
import secrets
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
SECRET_DIR = ROOT / "secrets"
PASSWORD_FILE = SECRET_DIR / "postgres_password"
DATABASE_FILE = SECRET_DIR / "database_url"
CACHE_FILE = SECRET_DIR / "cache_url"
MINIO_USER_FILE = SECRET_DIR / "minio_root_user"
MINIO_PASSWORD_FILE = SECRET_DIR / "minio_root_password"
S3_ACCESS_FILE = SECRET_DIR / "s3_access_key"
S3_SECRET_FILE = SECRET_DIR / "s3_secret_key"
ENV_FILE = ROOT / ".env"
ENV_EXAMPLE = ROOT / ".env.example"
def main():
files = (PASSWORD_FILE, DATABASE_FILE, CACHE_FILE)
if any(path.exists() for path in files) and not all(path.exists() for path in files):
print("secrets/ заполнены не полностью, ничего не перезаписываю", file=sys.stderr)
return 1
SECRET_DIR.mkdir(exist_ok=True)
if all(path.exists() for path in files):
print("secrets already exist")
else:
password = secrets.token_hex(24)
PASSWORD_FILE.write_text(password + "\n", encoding="utf-8")
DATABASE_FILE.write_text(
"postgresql://messenger:{}@postgres:5432/messenger\n".format(password),
encoding="utf-8",
)
CACHE_FILE.write_text("redis://redis:6379/0\n", encoding="utf-8")
print("secrets created")
s3_files = (MINIO_USER_FILE, MINIO_PASSWORD_FILE, S3_ACCESS_FILE, S3_SECRET_FILE)
if any(path.exists() for path in s3_files) and not all(path.exists() for path in s3_files):
print("secrets/ для MinIO заполнены не полностью, ничего не перезаписываю", file=sys.stderr)
return 1
if all(path.exists() for path in s3_files):
print("s3 secrets already exist")
else:
MINIO_USER_FILE.write_text("labroot", encoding="utf-8")
MINIO_PASSWORD_FILE.write_text(secrets.token_hex(24), encoding="utf-8")
S3_ACCESS_FILE.write_text("api" + secrets.token_hex(8), encoding="utf-8")
S3_SECRET_FILE.write_text(secrets.token_hex(24), encoding="utf-8")
print("s3 secrets created")
if ENV_FILE.exists():
print(".env already exists")
else:
ENV_FILE.write_text(ENV_EXAMPLE.read_text(encoding="utf-8"), encoding="utf-8")
print(".env created")
return 0
if __name__ == "__main__":
raise SystemExit(main())
+30
View File
@@ -0,0 +1,30 @@
#!/bin/sh
# Идемпотентно создаёт приватный bucket и отдельного пользователя API.
# Корневой пароль остаётся только у этого контейнера и у MinIO.
set -eu
ROOT_USER=$(tr -d '\r\n' < /run/secrets/minio_root_user)
ROOT_PW=$(tr -d '\r\n' < /run/secrets/minio_root_password)
ACCESS=$(tr -d '\r\n' < /run/secrets/s3_access_key)
SECRET=$(tr -d '\r\n' < /run/secrets/s3_secret_key)
attempt=0
until mc alias set local http://minio:9000 "$ROOT_USER" "$ROOT_PW" >/dev/null; do
attempt=$((attempt + 1))
if [ "$attempt" -gt 30 ]; then
echo "minio alias failed" >&2
exit 1
fi
sleep 1
done
mc mb --ignore-existing local/messenger-attachments >/dev/null
mc anonymous set none local/messenger-attachments >/dev/null
if ! mc admin user info local "$ACCESS" >/dev/null 2>&1; then
mc admin user add local "$ACCESS" "$SECRET" >/dev/null
fi
mc admin policy detach local messenger-api --user "$ACCESS" >/dev/null 2>&1 || true
mc admin policy rm local messenger-api >/dev/null 2>&1 || true
mc admin policy create local messenger-api /init/policy.json >/dev/null
mc admin policy attach local messenger-api --user "$ACCESS" >/dev/null
echo "minio bucket ready"
+8
View File
@@ -0,0 +1,8 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
# Рестарт API и всех хранилищ со состоянием. Volume не удаляем, миграции заново не заливаем.
# Балансировщик без своего состояния не трогаем: он продолжает слушать тот же порт.
docker compose --env-file .env restart postgres redis minio
docker compose --env-file .env up -d --wait --no-deps postgres redis minio
docker compose --env-file .env restart api
+29
View File
@@ -0,0 +1,29 @@
#!/bin/sh
set -eu
# Поочерёдный рестарт API-реплик. Следующую не трогаем, пока текущая снова healthy.
ids=$(docker ps -q \
--filter label=com.docker.compose.project=mtusi-lab4 \
--filter label=com.docker.compose.service=api)
if [ -z "$ids" ]; then
echo "no api replicas" >&2
exit 1
fi
for id in $ids; do
docker restart --time 5 "$id" >/dev/null
i=0
while [ "$i" -lt 40 ]; do
status=$(docker inspect -f '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}' "$id")
if [ "$status" = "healthy" ]; then
break
fi
i=$((i + 1))
sleep 1
done
if [ "$i" -ge 40 ]; then
echo "replica did not become healthy" >&2
exit 1
fi
# rise 2 у HAProxy: дать балансировщику вернуть реплику в ротацию.
sleep 2
done
+23
View File
@@ -0,0 +1,23 @@
#!/bin/sh
set -eu
: "${TARGET_INSTANCE_ID:?}"
found=""
for id in $(docker ps -q \
--filter label=com.docker.compose.project=mtusi-lab4 \
--filter label=com.docker.compose.service=api); do
host=$(docker inspect -f '{{.Config.Hostname}}' "$id")
short=$(printf %s "$id" | cut -c1-12)
if [ "$host" = "$TARGET_INSTANCE_ID" ] || [ "$short" = "$TARGET_INSTANCE_ID" ]; then
found=$id
break
fi
done
if [ -z "$found" ]; then
echo "api replica not found" >&2
exit 1
fi
# SIGTERM, затем процесс остаётся остановленным (restart: unless-stopped).
docker stop --time 5 "$found" >/dev/null
+30
View File
@@ -0,0 +1,30 @@
#!/usr/bin/env python3
"""Ждать GET /health/ready через балансировщик. Без токенов и тел ошибок в выводе."""
import os
import sys
import time
import urllib.error
import urllib.request
URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/") + "/health/ready"
def main():
deadline = time.monotonic() + 90
last = "not-started"
while time.monotonic() < deadline:
try:
response = urllib.request.urlopen(URL, timeout=2)
if response.status == 200 and response.headers.get("X-Instance-Id"):
print("ready")
return 0
last = str(response.status)
except (urllib.error.URLError, TimeoutError, OSError) as exc:
last = type(exc).__name__
time.sleep(1)
print("not ready: " + last, file=sys.stderr)
return 1
if __name__ == "__main__":
raise SystemExit(main())
+190
View File
@@ -0,0 +1,190 @@
"""Проверка PNG/JPEG и доступ к приватному bucket. Ключ объекта назначает сервер."""
import io
import os
from datetime import datetime, timezone
from minio import Minio
from minio.error import S3Error
from PIL import Image, UnidentifiedImageError
from PIL.Image import DecompressionBombError
from errors import ApiError, DependencyDown
MAX_BYTES = 10 * 1024 * 1024
MAX_PIXELS = 40_000_000
BUCKET = os.environ.get("S3_BUCKET", "messenger-attachments")
Image.MAX_IMAGE_PIXELS = MAX_PIXELS
_client = None
def read_secret(path):
with open(path, encoding="utf-8") as handle:
return handle.read().strip()
def client():
global _client
if _client is None:
endpoint = os.environ.get("S3_ENDPOINT", "minio:9000").strip()
access = read_secret(os.environ["S3_ACCESS_KEY_FILE"])
secret = read_secret(os.environ["S3_SECRET_KEY_FILE"])
secure = os.environ.get("S3_SECURE", "false").strip().lower() == "true"
_client = Minio(endpoint, access_key=access, secret_key=secret, secure=secure)
return _client
def bucket_ready():
try:
return client().bucket_exists(BUCKET)
except Exception:
return False
def put_bytes(key, data, content_type, created_at):
stamp = created_at.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
try:
client().put_object(
BUCKET,
key,
io.BytesIO(data),
length=len(data),
content_type=content_type,
metadata={"created-at": stamp},
)
except S3Error as exc:
raise DependencyDown() from exc
def delete_quiet(key):
try:
client().remove_object(BUCKET, key)
return True
except Exception:
return False
def open_object(key):
try:
return client().get_object(BUCKET, key)
except S3Error as exc:
code = getattr(exc, "code", "")
if code in ("NoSuchKey", "NoSuchBucket"):
return None
raise DependencyDown() from exc
def object_key(chat_id, attachment_id):
return "chats/{}/attachments/{}/original".format(chat_id, attachment_id)
def declared_type(header):
if not header:
return None
media = header.split(";", 1)[0].strip().lower()
if media in ("image/png", "image/jpeg"):
return media
return None
def _png_size(data):
if len(data) < 24 or data[:8] != b"\x89PNG\r\n\x1a\n" or data[12:16] != b"IHDR":
return None
width = int.from_bytes(data[16:20], "big")
height = int.from_bytes(data[20:24], "big")
return width, height
def _jpeg_size(data):
if len(data) < 4 or data[:2] != b"\xff\xd8":
return None
index = 2
limit = len(data)
while index + 8 < limit:
if data[index] != 0xFF:
return None
while index < limit and data[index] == 0xFF:
index += 1
if index >= limit:
return None
marker = data[index]
index += 1
if marker in (0xD8, 0xD9):
continue
if index + 2 > limit:
return None
segment = int.from_bytes(data[index:index + 2], "big")
if segment < 2 or index + segment > limit:
return None
if marker in (0xC0, 0xC1, 0xC2):
if segment < 7:
return None
height = int.from_bytes(data[index + 3:index + 5], "big")
width = int.from_bytes(data[index + 5:index + 7], "big")
return width, height
index += segment
return None
def _too_many_pixels(width, height):
if width <= 0 or height <= 0:
raise ApiError(415, "unsupported_media_type", "Файл не является PNG или JPEG")
if width > MAX_PIXELS or height > MAX_PIXELS or width * height > MAX_PIXELS:
raise ApiError(413, "payload_too_large", "В изображении больше 40 миллионов пикселей")
def inspect_image(data, declared):
if declared == "image/png":
size = _png_size(data)
elif declared == "image/jpeg":
size = _jpeg_size(data)
else:
size = None
detected = None
if data.startswith(b"\x89PNG\r\n\x1a\n"):
detected = "image/png"
elif data.startswith(b"\xff\xd8\xff"):
detected = "image/jpeg"
if size is None or detected != declared:
raise ApiError(415, "unsupported_media_type", "Файл не является PNG или JPEG")
_too_many_pixels(size[0], size[1])
try:
with Image.open(io.BytesIO(data)) as image:
image.load()
except DecompressionBombError as exc:
raise ApiError(413, "payload_too_large", "В изображении больше 40 миллионов пикселей") from exc
except (UnidentifiedImageError, OSError, SyntaxError, ValueError) as exc:
raise ApiError(415, "unsupported_media_type", "Файл не является PNG или JPEG") from exc
return declared
def list_objects():
found = []
try:
for item in client().list_objects(BUCKET, prefix="chats/", recursive=True):
if item.is_dir:
continue
stat = client().stat_object(BUCKET, item.object_name)
raw = None
if stat.metadata:
meta = {str(key).lower(): value for key, value in stat.metadata.items()}
raw = meta.get("x-amz-meta-created-at") or meta.get("created-at")
created = _parse_stamp(raw) if raw else None
if created is None and item.last_modified is not None:
created = item.last_modified
found.append({"key": item.object_name, "created_at": created})
except S3Error as exc:
raise DependencyDown() from exc
return found
def _parse_stamp(value):
text = value.strip().replace("Z", "+00:00")
try:
parsed = datetime.fromisoformat(text)
except ValueError:
return None
if parsed.tzinfo is None:
parsed = parsed.replace(tzinfo=timezone.utc)
return parsed
+28
View File
@@ -0,0 +1,28 @@
class ApiError(Exception):
def __init__(self, status, code, message, headers=None):
self.status = status
self.code = code
self.message = message
self.headers = headers or {}
class DependencyDown(Exception):
"""Postgres или Redis не ответили. Наружу это 503 без имени хранилища."""
class IdempotencyConflict(Exception):
"""Тот же Idempotency-Key уже зафиксирован с другим телом."""
class AttachmentRejected(Exception):
"""Вложение есть, но прикрепить его к сообщению нельзя."""
def error_body(code, message, request_id):
return {
"error": {
"code": code,
"message": message,
"request_id": request_id,
}
}
+471
View File
@@ -0,0 +1,471 @@
import json
import logging
import os
import re
import uuid
from contextlib import asynccontextmanager
import anyio
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse, Response, StreamingResponse
from pydantic import ValidationError
from starlette.exceptions import HTTPException as StarletteHTTPException
from blobs import MAX_BYTES, declared_type, inspect_image, open_object
from errors import ApiError, AttachmentRejected, DependencyDown, IdempotencyConflict, error_body
from schemas import CreateChat, CreateMessage, CreateUser
from store import Store, instance_id
LOGGER = logging.getLogger("messenger")
store = Store()
INSTANCE_ID = instance_id()
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
IDEMPOTENCY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
MAX_JSON_BYTES = 65536
@asynccontextmanager
async def lifespan(_app):
await anyio.to_thread.run_sync(store.startup)
yield
store.shutting_down = True
await anyio.to_thread.run_sync(store.shutdown)
app = FastAPI(
title="mtusi-messenger",
version="lab4",
lifespan=lifespan,
redirect_slashes=False,
docs_url="/docs",
redoc_url=None,
openapi_url="/openapi.json",
)
def request_id_of(request: Request):
rid = getattr(request.state, "request_id", None)
if rid:
return rid
return str(uuid.uuid4())
def stamp(request: Request, response):
response.headers["X-Request-Id"] = request_id_of(request)
response.headers["X-Instance-Id"] = INSTANCE_ID
return response
def json_ok(request: Request, payload, status_code=200):
return stamp(request, JSONResponse(payload, status_code=status_code))
def json_error(request: Request, status, code, message, extra_headers=None):
headers = {"X-Request-Id": request_id_of(request), "X-Instance-Id": INSTANCE_ID}
if extra_headers:
headers.update(extra_headers)
return JSONResponse(error_body(code, message, request_id_of(request)), status_code=status, headers=headers)
@app.middleware("http")
async def wrap_request(request: Request, call_next):
incoming = request.headers.get("X-Request-Id", "")
if incoming and len(incoming) <= 200 and incoming.isprintable() and incoming.strip():
request.state.request_id = incoming.strip()
else:
request.state.request_id = str(uuid.uuid4())
if store.shutting_down and request.url.path != "/health/live":
return json_error(request, 503, "unavailable", "Сервис временно недоступен")
response = await call_next(request)
return stamp(request, response)
@app.exception_handler(ApiError)
async def api_error_handler(request: Request, exc: ApiError):
return json_error(request, exc.status, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def request_validation_handler(request: Request, _exc: RequestValidationError):
return json_error(request, 400, "invalid_request", "Некорректный запрос")
@app.exception_handler(ValidationError)
async def pydantic_handler(request: Request, _exc: ValidationError):
return json_error(request, 400, "invalid_request", "Некорректный запрос")
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
if exc.status_code == 404:
return json_error(request, 404, "not_found", "Объект не найден")
return json_error(request, exc.status_code if exc.status_code < 500 else 500, "invalid_request", "Некорректный запрос")
@app.exception_handler(Exception)
async def unexpected_handler(request: Request, exc: Exception):
if isinstance(exc, ApiError):
return json_error(request, exc.status, exc.code, exc.message, exc.headers)
LOGGER.exception("unhandled")
return json_error(request, 500, "internal_error", "Внутренняя ошибка")
def unavailable():
raise ApiError(503, "unavailable", "Сервис временно недоступен")
def bearer_unauthorized():
raise ApiError(401, "unauthorized", "Требуется авторизация", {"WWW-Authenticate": BEARER_CHALLENGE})
def basic_unauthorized():
raise ApiError(401, "unauthorized", "Неверные учётные данные", {"WWW-Authenticate": BASIC_CHALLENGE})
def invalid():
raise ApiError(400, "invalid_request", "Некорректный запрос")
async def call_store(func, *args):
try:
return await anyio.to_thread.run_sync(func, *args)
except DependencyDown:
unavailable()
except IdempotencyConflict:
raise ApiError(409, "conflict", "Ключ уже использован с другим телом")
except AttachmentRejected:
raise ApiError(409, "conflict", "Вложение нельзя прикрепить")
def parse_basic(request: Request):
header = request.headers.get("Authorization", "")
if not header.lower().startswith("basic "):
basic_unauthorized()
raw = header.split(" ", 1)[1].strip()
try:
import base64
decoded = base64.b64decode(raw, validate=True).decode("utf-8")
except (ValueError, UnicodeError):
basic_unauthorized()
if ":" not in decoded:
basic_unauthorized()
username, password = decoded.split(":", 1)
return username, password
def parse_bearer(request: Request):
header = request.headers.get("Authorization", "")
# Basic на бизнес-методе не открывает сессию. X-User-Id не смотрим.
if not header.lower().startswith("bearer "):
bearer_unauthorized()
token = header.split(" ", 1)[1].strip()
if len(token) < 32 or len(token) > 512 or any(ch.isspace() for ch in token):
bearer_unauthorized()
return token
async def current_user(request: Request):
token = parse_bearer(request)
user = await call_store(store.user_for_token, token)
if user is None:
bearer_unauthorized()
request.state.user_id = user["id"]
request.state.token = token
return user
def parse_chat_id(chat_id):
try:
return str(uuid.UUID(chat_id))
except ValueError:
invalid()
def parse_limit(raw):
if raw is None:
return 50
if not isinstance(raw, str) or len(raw) > 3 or not raw.isdigit():
invalid()
value = int(raw)
if value < 1 or value > 100:
invalid()
return value
async def read_json(request: Request):
ctype = request.headers.get("content-type", "")
if "application/json" not in ctype.lower():
raise ApiError(415, "unsupported_media_type", "Нужен application/json")
length = request.headers.get("content-length")
if length is not None and (not length.isdigit() or int(length) > MAX_JSON_BYTES):
raise ApiError(413, "payload_too_large", "Слишком большое тело")
raw = await request.body()
if len(raw) > MAX_JSON_BYTES:
raise ApiError(413, "payload_too_large", "Слишком большое тело")
try:
payload = json.loads(raw)
except (ValueError, UnicodeError):
invalid()
if not isinstance(payload, dict):
invalid()
return payload
def parse_idempotency_key(request: Request):
key = request.headers.get("Idempotency-Key")
if key is None or not IDEMPOTENCY_RE.fullmatch(key):
invalid()
return key
@app.get("/health/live")
async def liveness(request: Request):
return json_ok(request, {"status": "ok"})
@app.get("/health/ready")
async def readiness(request: Request):
if store.shutting_down:
raise ApiError(503, "unavailable", "Сервис временно недоступен")
ok = await call_store(store.ready)
if not ok:
unavailable()
return json_ok(request, {"status": "ok"})
@app.post("/api/v1/users", status_code=201)
async def register_user(request: Request, body: CreateUser):
user = await call_store(store.create_user, body.username, body.display_name, body.password)
if user is None:
raise ApiError(409, "conflict", "Имя пользователя занято")
return json_ok(request, user, 201)
@app.post("/api/v1/auth/sessions", status_code=201)
async def create_session(request: Request):
username, password = parse_basic(request)
session = await call_store(store.login, username, password)
if session is None:
basic_unauthorized()
request.state.user_id = session["user"]["id"]
return json_ok(request, session, 201)
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def revoke_session(request: Request):
user = await current_user(request)
request.state.user_id = user["id"]
removed = await call_store(store.revoke, request.state.token)
if not removed:
bearer_unauthorized()
return stamp(request, Response(status_code=204))
@app.get("/api/v1/users/me")
async def me(request: Request):
user = await current_user(request)
return json_ok(request, user)
@app.post("/api/v1/chats", status_code=201)
async def create_chat(request: Request):
user = await current_user(request)
payload = await read_json(request)
try:
body = CreateChat.model_validate(payload)
except ValidationError:
invalid()
try:
chat = await call_store(store.create_chat, body.title, body.member_ids, user["id"])
except ValueError:
invalid()
return json_ok(request, chat, 201)
@app.get("/api/v1/chats")
async def list_chats(request: Request):
user = await current_user(request)
limit = parse_limit(request.query_params.get("limit"))
cursor = request.query_params.get("cursor")
if cursor is not None and (not cursor or len(cursor) > 512):
invalid()
try:
items, next_cursor = await call_store(store.list_chats, user["id"], limit, cursor)
except ValueError:
invalid()
return json_ok(request, {"items": items, "next_cursor": next_cursor})
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(request: Request, chat_id: str):
user = await current_user(request)
chat = await call_store(store.get_chat, parse_chat_id(chat_id), user["id"])
if chat is None:
raise ApiError(404, "not_found", "Объект не найден")
return json_ok(request, chat)
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def create_message(request: Request, chat_id: str):
user = await current_user(request)
canonical = parse_chat_id(chat_id)
payload = await read_json(request)
key = parse_idempotency_key(request)
try:
body = CreateMessage.model_validate(payload)
except ValidationError:
invalid()
try:
message = await call_store(
store.add_message, canonical, user["id"], body.text, key, body.attachment_ids
)
except ValueError:
invalid()
if message is None:
raise ApiError(404, "not_found", "Объект не найден")
return json_ok(request, message, 201)
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(request: Request, chat_id: str):
user = await current_user(request)
canonical = parse_chat_id(chat_id)
limit = parse_limit(request.query_params.get("limit"))
cursor = request.query_params.get("cursor")
if cursor is not None and (not cursor or len(cursor) > 512):
invalid()
try:
result = await call_store(store.list_messages, canonical, user["id"], limit, cursor)
except ValueError:
invalid()
if result is None:
raise ApiError(404, "not_found", "Объект не найден")
items, next_cursor = result
return json_ok(request, {"items": items, "next_cursor": next_cursor})
def check_filename(value):
if not isinstance(value, str) or not value or len(value) > 255:
invalid()
if "/" in value or "\\" in value or "\x00" in value:
invalid()
if any(ord(char) < 32 or ord(char) == 127 for char in value):
invalid()
return value
def parse_attachment_id(value):
try:
return str(uuid.UUID(value))
except (TypeError, ValueError):
invalid()
async def read_upload(request: Request):
header = request.headers.get("content-length")
if header is not None:
try:
announced = int(header)
except ValueError:
invalid()
if announced > MAX_BYTES:
raise ApiError(413, "payload_too_large", "Файл больше 10 МиБ")
if announced < 1:
raise ApiError(415, "unsupported_media_type", "Нужен PNG или JPEG")
chunks = []
total = 0
async for chunk in request.stream():
total += len(chunk)
if total > MAX_BYTES:
raise ApiError(413, "payload_too_large", "Файл больше 10 МиБ")
chunks.append(chunk)
if total < 1:
raise ApiError(415, "unsupported_media_type", "Нужен PNG или JPEG")
return b"".join(chunks)
@app.post("/api/v1/chats/{chat_id}/attachments", status_code=201)
async def upload_attachment(request: Request, chat_id: str):
user = await current_user(request)
canonical = parse_chat_id(chat_id)
member = await call_store(store.is_member, canonical, user["id"])
if not member:
raise ApiError(404, "not_found", "Объект не найден")
filename = check_filename(request.query_params.get("filename"))
media = declared_type(request.headers.get("content-type"))
if media is None:
raise ApiError(415, "unsupported_media_type", "Нужен PNG или JPEG")
data = await read_upload(request)
content_type = await anyio.to_thread.run_sync(inspect_image, data, media)
saved = await call_store(
store.save_attachment, canonical, user["id"], filename, content_type, data
)
if saved is None:
raise ApiError(404, "not_found", "Объект не найден")
return json_ok(request, saved, 201)
@app.get("/api/v1/attachments/{attachment_id}")
async def get_attachment(request: Request, attachment_id: str):
user = await current_user(request)
canonical = parse_attachment_id(attachment_id)
found = await call_store(store.get_attachment, canonical, user["id"])
if found is None:
raise ApiError(404, "not_found", "Объект не найден")
return json_ok(request, found)
@app.get("/api/v1/attachments/{attachment_id}/content")
async def download_attachment(request: Request, attachment_id: str):
user = await current_user(request)
canonical = parse_attachment_id(attachment_id)
variant = request.query_params.get("variant")
if variant not in (None, "original"):
raise ApiError(404, "not_found", "Объект не найден")
opened = await call_store(store.open_attachment, canonical, user["id"])
if opened is None:
raise ApiError(404, "not_found", "Объект не найден")
def chunks():
body = open_object(opened["object_key"])
if body is None:
return
try:
for piece in body.stream(64 * 1024):
yield piece
finally:
body.close()
body.release_conn()
probe = await anyio.to_thread.run_sync(open_object, opened["object_key"])
if probe is None:
raise ApiError(404, "not_found", "Объект не найден")
probe.close()
probe.release_conn()
response = StreamingResponse(chunks(), media_type=opened["content_type"])
response.headers["Content-Length"] = str(opened["size_bytes"])
return stamp(request, response)
def setup_logging():
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
if __name__ == "__main__":
import uvicorn
setup_logging()
host = os.environ.get("APP_HOST", "0.0.0.0")
port = int(os.environ.get("APP_PORT", "8080"))
uvicorn.run(
app,
host=host,
port=port,
timeout_graceful_shutdown=5,
timeout_keep_alive=2,
access_log=False,
)
+112
View File
@@ -0,0 +1,112 @@
"""Однократные миграции. Запускается отдельным контейнером, не каждой репликой API."""
import logging
import os
import sys
import time
from pathlib import Path
import psycopg
from psycopg.rows import dict_row
LOGGER = logging.getLogger("migrate")
MIGRATION_LOCK = 421003
CONNECT_TIMEOUT = 3
def read_secret_file(path):
with open(path, encoding="utf-8") as handle:
return handle.read().strip()
def database_url():
path = os.environ.get("DATABASE_URL_FILE")
if path:
return read_secret_file(path)
url = os.environ.get("DATABASE_URL", "").strip()
if not url:
raise RuntimeError("DATABASE_URL_FILE")
return url
def split_sql(script):
parts = []
buf = []
for line in script.splitlines():
if line.strip().startswith("--"):
continue
buf.append(line)
if line.strip().endswith(";"):
statement = "\n".join(buf).strip()
if statement.endswith(";"):
statement = statement[:-1].strip()
if statement:
parts.append(statement)
buf = []
tail = "\n".join(buf).strip().rstrip(";").strip()
if tail:
parts.append(tail)
return parts
def wait_postgres(conninfo):
last = None
for _ in range(60):
try:
with psycopg.connect(conninfo, connect_timeout=CONNECT_TIMEOUT) as conn:
conn.execute("SELECT 1")
return
except psycopg.OperationalError as exc:
last = type(exc).__name__
time.sleep(1)
LOGGER.error("postgres not ready: %s", last)
raise SystemExit(1)
def apply(conninfo):
directory = Path(__file__).resolve().parents[1] / "migrations"
with psycopg.connect(conninfo, connect_timeout=CONNECT_TIMEOUT, row_factory=dict_row) as conn:
conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATION_LOCK,))
conn.commit()
try:
conn.execute(
"""
CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY,
applied_at timestamptz NOT NULL DEFAULT now()
)
"""
)
conn.commit()
for path in sorted(directory.glob("*.sql")):
version = path.stem
found = conn.execute(
"SELECT 1 FROM schema_migrations WHERE version = %s",
(version,),
).fetchone()
conn.rollback()
if found:
LOGGER.info("migration %s already applied", version)
continue
with conn.transaction():
for statement in split_sql(path.read_text(encoding="utf-8")):
conn.execute(statement)
conn.execute(
"INSERT INTO schema_migrations (version) VALUES (%s)",
(version,),
)
LOGGER.info("migration %s applied", version)
finally:
conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATION_LOCK,))
conn.commit()
def main():
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
conninfo = database_url()
wait_postgres(conninfo)
apply(conninfo)
return 0
if __name__ == "__main__":
sys.exit(main())
+26
View File
@@ -0,0 +1,26 @@
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHash, VerificationError, VerifyMismatchError
# Параметры ближе к учебному стенду, чем к максимальным: time=2, 19 MiB, Argon2id.
# Хеш всё равно медленный password KDF, не SHA-256 и не открытый текст.
hasher = PasswordHasher(
time_cost=2,
memory_cost=19456,
parallelism=1,
hash_len=32,
salt_len=16,
)
# Чтобы неизвестный username не отвечал заметно быстрее известного.
DUMMY_HASH = hasher.hash("dummy-password-not-a-user")
def hash_password(password):
return hasher.hash(password)
def verify_password(password, encoded):
try:
return hasher.verify(encoded, password)
except (VerifyMismatchError, VerificationError, InvalidHash):
return False
+154
View File
@@ -0,0 +1,154 @@
"""Сверка строк attachments и объектов bucket.
Свежий объект моложе grace не удаляется: загрузка могла записать файл
раньше, чем строка в базе. Строка, на которую ссылается сообщение, тоже
не удаляется, даже если файла уже нет. По умолчанию только план, без удалений.
"""
import argparse
import json
import os
import sys
import time
from datetime import datetime, timezone
import psycopg
from psycopg.rows import dict_row
from blobs import BUCKET, delete_quiet, list_objects
def grace_seconds():
raw = os.environ.get("RECONCILE_GRACE_SECONDS", "120")
value = int(raw)
if value < 1:
raise RuntimeError("RECONCILE_GRACE_SECONDS")
return value
def database_url():
path = os.environ.get("DATABASE_URL_FILE")
if not path:
raise RuntimeError("DATABASE_URL_FILE")
with open(path, encoding="utf-8") as handle:
return handle.read().strip()
def aware(value):
if value is None:
return None
if value.tzinfo is None:
return value.replace(tzinfo=timezone.utc)
return value.astimezone(timezone.utc)
def plan(grace):
started = time.perf_counter()
objects = list_objects()
listed = time.perf_counter()
now = datetime.now(timezone.utc)
with psycopg.connect(database_url(), row_factory=dict_row) as conn:
rows = conn.execute(
"""
SELECT a.id, a.object_key, a.created_at,
EXISTS (
SELECT 1 FROM message_attachments m
WHERE m.attachment_id = a.id
) AS in_use
FROM attachments a
"""
).fetchall()
by_key = {row["object_key"]: row for row in rows}
object_keys = {item["key"] for item in objects}
actions = []
preserved = []
for item in objects:
row = by_key.get(item["key"])
if row is not None:
continue
created = aware(item["created_at"]) or now
age = (now - created).total_seconds()
entry = {"key": item["key"], "age_seconds": round(age, 3)}
if age < grace:
entry["reason"] = "fresh_object"
preserved.append(entry)
continue
entry["action"] = "delete_orphan_object"
actions.append(entry)
for row in rows:
if row["object_key"] in object_keys:
continue
created = aware(row["created_at"]) or now
age = (now - created).total_seconds()
entry = {
"attachment_id": str(row["id"]),
"key": row["object_key"],
"age_seconds": round(age, 3),
}
if row["in_use"]:
entry["reason"] = "missing_but_in_use"
preserved.append(entry)
continue
if age < grace:
entry["reason"] = "fresh_row"
preserved.append(entry)
continue
entry["action"] = "delete_orphan_row"
actions.append(entry)
return {
"bucket": BUCKET,
"grace_seconds": grace,
"objects": len(objects),
"rows": len(rows),
"list_seconds": round(listed - started, 6),
"plan_seconds": round(time.perf_counter() - started, 6),
"actions": actions,
"preserved": preserved,
}
def apply_plan(report):
deleted_objects = 0
deleted_rows = 0
with psycopg.connect(database_url(), row_factory=dict_row) as conn:
for action in report["actions"]:
if action["action"] == "delete_orphan_object":
if delete_quiet(action["key"]):
deleted_objects += 1
elif action["action"] == "delete_orphan_row":
with conn.transaction():
result = conn.execute(
"""
DELETE FROM attachments
WHERE id = %s
AND NOT EXISTS (
SELECT 1 FROM message_attachments m
WHERE m.attachment_id = attachments.id
)
""",
(action["attachment_id"],),
)
deleted_rows += result.rowcount
report["deleted_objects"] = deleted_objects
report["deleted_rows"] = deleted_rows
return report
def main():
parser = argparse.ArgumentParser(description="Сверить вложения в базе и в bucket")
parser.add_argument("--apply", action="store_true", help="выполнить удаления; без флага только план")
parser.add_argument("--grace", type=int, default=None)
args = parser.parse_args()
grace = args.grace if args.grace is not None else grace_seconds()
if grace < 1:
print("grace должен быть не меньше 1 секунды", file=sys.stderr)
return 2
report = plan(grace)
report["apply"] = bool(args.apply)
if args.apply:
apply_plan(report)
print(json.dumps(report, ensure_ascii=False, sort_keys=True))
return 0
if __name__ == "__main__":
raise SystemExit(main())
+128
View File
@@ -0,0 +1,128 @@
import re
import uuid
from pydantic import BaseModel, ConfigDict, field_validator, model_validator
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
class StrictModel(BaseModel):
model_config = ConfigDict(extra="forbid")
def _visible(value, limit):
if not isinstance(value, str) or not value.strip() or len(value) > limit:
raise ValueError("text")
return value
class CreateUser(StrictModel):
username: str
display_name: str
password: str
@field_validator("username")
@classmethod
def username_ok(cls, value):
if not isinstance(value, str) or not USERNAME_RE.fullmatch(value):
raise ValueError("username")
return value
@field_validator("display_name")
@classmethod
def display_name_ok(cls, value):
return _visible(value, 100)
@field_validator("password")
@classmethod
def password_ok(cls, value):
if not isinstance(value, str) or not value.strip():
raise ValueError("password")
# Длина в code points, не в байтах: bcrypt тут не подходит из-за усечения UTF-8.
if len(value) < 12 or len(value) > 128:
raise ValueError("password")
return value
class CreateChat(StrictModel):
title: str
member_ids: list
@field_validator("title")
@classmethod
def title_ok(cls, value):
return _visible(value, 100)
@field_validator("member_ids")
@classmethod
def member_ids_ok(cls, value):
if not isinstance(value, list) or not (1 <= len(value) <= 100):
raise ValueError("member_ids")
# Канонический UUID (нижний регистр). Иначе один и тот же id
# в разном регистре выглядит как два участника и упирается в PK.
normalized = []
seen = set()
for item in value:
if not isinstance(item, str):
raise ValueError("member_ids")
try:
canonical = str(uuid.UUID(item))
except ValueError as exc:
raise ValueError("member_ids") from exc
if canonical in seen:
raise ValueError("member_ids")
seen.add(canonical)
normalized.append(canonical)
return normalized
class CreateMessage(StrictModel):
text: str
attachment_ids: list = []
@model_validator(mode="before")
@classmethod
def fill_attachments(cls, value):
# Нет поля и явный [] — одно и то же тело для Idempotency-Key.
if not isinstance(value, dict):
return value
data = dict(value)
data.setdefault("attachment_ids", [])
return data
@field_validator("text")
@classmethod
def text_ok(cls, value):
if not isinstance(value, str) or len(value) > 4000:
raise ValueError("text")
if value != "" and not value.strip():
raise ValueError("text")
return value
@field_validator("attachment_ids")
@classmethod
def attachments_ok(cls, value):
if not isinstance(value, list) or len(value) > 10:
raise ValueError("attachment_ids")
normalized = []
seen = set()
for item in value:
if not isinstance(item, str):
raise ValueError("attachment_ids")
try:
canonical = str(uuid.UUID(item))
except ValueError as exc:
raise ValueError("attachment_ids") from exc
if canonical in seen:
raise ValueError("attachment_ids")
seen.add(canonical)
normalized.append(canonical)
return normalized
@model_validator(mode="after")
def text_or_file(self):
if self.text == "" and not self.attachment_ids:
raise ValueError("text")
if self.text and not self.text.strip():
raise ValueError("text")
return self
+774
View File
@@ -0,0 +1,774 @@
import base64
import hashlib
import json
import logging
import os
import secrets
import socket
import time
import uuid
from datetime import datetime, timedelta, timezone
import psycopg
import redis
from psycopg.errors import CheckViolation, ForeignKeyViolation, UniqueViolation
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool, PoolTimeout
from errors import AttachmentRejected, DependencyDown, IdempotencyConflict
from passwords import DUMMY_HASH, hash_password, verify_password
LOGGER = logging.getLogger("messenger")
POOL_TIMEOUT_SECONDS = 3
STATEMENT_TIMEOUT_MS = 5000
LOCK_TIMEOUT_MS = 3000
REDIS_MAX_CONNECTIONS = 16
REDIS_SOCKET_TIMEOUT = 2
SCHEMA_VERSION = "003_attachments"
SQL_MESSAGES_FIRST = """
SELECT id, chat_id, sender_id, body AS text, created_at
FROM messages
WHERE chat_id = %s
ORDER BY created_at, id
LIMIT %s
"""
SQL_MESSAGES_AFTER = """
SELECT id, chat_id, sender_id, body AS text, created_at
FROM messages
WHERE chat_id = %s
AND (created_at, id) > (%s, %s)
ORDER BY created_at, id
LIMIT %s
"""
SQL_MESSAGE_BY_ID = """
SELECT id, chat_id, sender_id, body AS text, created_at
FROM messages
WHERE id = %s
"""
def instance_id():
# Docker без hostname: в контейнере это id контейнера, он не меняется,
# пока живёт этот контейнер. stop-one.sh находит контейнер по этому значению.
return socket.gethostname()
def pool_max():
raw = os.environ.get("POOL_MAX", "10")
try:
value = int(raw)
except ValueError as exc:
raise RuntimeError("POOL_MAX") from exc
if not 1 <= value <= 32:
raise RuntimeError("POOL_MAX")
return value
def utc_now():
return datetime.now(timezone.utc)
def dump_time(value):
if value.tzinfo is None:
value = value.replace(tzinfo=timezone.utc)
text = value.astimezone(timezone.utc).isoformat(timespec="microseconds")
if text.endswith("+00:00"):
text = text[:-6] + "Z"
return text
def parse_time(value):
if not isinstance(value, str) or not value.endswith("Z"):
raise ValueError("time")
return datetime.fromisoformat(value[:-1] + "+00:00")
def encode_cursor(scope, created_at, item_id):
raw = "{}|{}|{}".format(scope, created_at, item_id).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
def decode_cursor(cursor, expected_scope):
if not isinstance(cursor, str) or not cursor or len(cursor) > 512:
raise ValueError("cursor")
pad = "=" * (-len(cursor) % 4)
try:
decoded = base64.urlsafe_b64decode(cursor + pad).decode("utf-8")
except (ValueError, UnicodeError) as exc:
raise ValueError("cursor") from exc
parts = decoded.split("|")
if len(parts) != 3:
raise ValueError("cursor")
scope, created_at, item_id = parts
if scope != expected_scope:
raise ValueError("cursor")
parse_time(created_at)
try:
uuid.UUID(item_id)
except ValueError as exc:
raise ValueError("cursor") from exc
return created_at, item_id
def session_key(token):
digest = hashlib.sha256(token.encode("utf-8")).hexdigest()
return "sess:" + digest
def message_fingerprint(text, attachment_ids):
# Канонический JSON: порядок ключей не важен, пропущенный attachment_ids равен [].
canonical = json.dumps(
{"attachment_ids": list(attachment_ids), "text": text},
ensure_ascii=False,
sort_keys=True,
separators=(",", ":"),
)
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
def advisory_key(user_id, path, idem_key):
raw = "\0".join((user_id, "POST", path, idem_key)).encode("utf-8")
digest = hashlib.sha256(raw).digest()
return int.from_bytes(digest[:8], "big", signed=True)
def chat_path(chat_id):
return "/api/v1/chats/" + chat_id + "/messages"
def public_user(row):
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": dump_time(row["created_at"]),
}
def public_message(row, attachment_ids=None):
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"attachment_ids": list(attachment_ids or []),
"created_at": dump_time(row["created_at"]),
}
def public_attachment(row):
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": int(row["size_bytes"]),
"sha256": row["sha256"],
"status": "ready",
"variants": [],
"error_code": None,
"created_at": dump_time(row["created_at"]),
"updated_at": dump_time(row["updated_at"]),
}
def public_chat(row, member_ids=None):
members = member_ids if member_ids is not None else row["member_ids"]
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(item) for item in members],
"created_at": dump_time(row["created_at"]),
}
def read_secret_file(path):
with open(path, encoding="utf-8") as handle:
return handle.read().strip()
def _db_down(exc):
raise DependencyDown() from exc
class Store:
def __init__(self):
self.pool = None
self.redis = None
self.ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
self.idem_ttl = int(os.environ.get("IDEMPOTENCY_TTL_SECONDS", "86400"))
self.pool_size = pool_max()
self.shutting_down = False
if self.ttl < 1 or self.idem_ttl < 1:
raise RuntimeError("TTL")
kind = os.environ.get("SESSION_STORE", "redis").strip().lower()
if kind != "redis":
raise RuntimeError("SESSION_STORE")
def database_url(self):
path = os.environ.get("DATABASE_URL_FILE")
if path:
return read_secret_file(path)
url = os.environ.get("DATABASE_URL", "").strip()
if not url:
raise RuntimeError("DATABASE_URL_FILE")
return url
def redis_url(self):
path = os.environ.get("CACHE_URL_FILE")
if path:
return read_secret_file(path)
url = os.environ.get("CACHE_URL", "").strip()
if not url:
raise RuntimeError("CACHE_URL_FILE")
return url
def startup(self):
conninfo = self.database_url()
self._wait_schema(conninfo)
self.pool = ConnectionPool(
conninfo,
min_size=1,
max_size=self.pool_size,
timeout=POOL_TIMEOUT_SECONDS,
max_waiting=64,
max_lifetime=300,
kwargs={
"connect_timeout": POOL_TIMEOUT_SECONDS,
"row_factory": dict_row,
"application_name": "mtusi-lab4-" + instance_id(),
"options": "-c statement_timeout={} -c lock_timeout={} -c idle_in_transaction_session_timeout=15000".format(
STATEMENT_TIMEOUT_MS,
LOCK_TIMEOUT_MS,
),
},
open=True,
)
pool = redis.ConnectionPool.from_url(
self.redis_url(),
max_connections=REDIS_MAX_CONNECTIONS,
socket_timeout=REDIS_SOCKET_TIMEOUT,
socket_connect_timeout=REDIS_SOCKET_TIMEOUT,
health_check_interval=30,
decode_responses=True,
)
self.redis = redis.Redis(connection_pool=pool)
self._wait_redis()
self._wait_bucket()
LOGGER.info("ready instance=%s ttl=%s pool_max=%s", instance_id(), self.ttl, self.pool_size)
def shutdown(self):
self.shutting_down = True
if self.pool is not None:
self.pool.close()
if self.redis is not None:
self.redis.close()
def ready(self):
if self.shutting_down or self.pool is None or self.redis is None:
return False
try:
with self.pool.connection(timeout=POOL_TIMEOUT_SECONDS) as conn:
row = conn.execute(
"SELECT 1 FROM schema_migrations WHERE version = %s",
(SCHEMA_VERSION,),
).fetchone()
if row is None:
return False
self.redis.ping()
from blobs import bucket_ready
if not bucket_ready():
return False
except Exception:
LOGGER.warning("ready check failed")
return False
return True
def _wait_redis(self):
last = None
for _ in range(60):
try:
self.redis.ping()
return
except redis.RedisError as exc:
last = type(exc).__name__
time.sleep(1)
LOGGER.error("redis not ready: %s", last)
raise SystemExit(1)
def _wait_schema(self, conninfo):
# Схему накатывает сервис migrate. Реплики только ждут её, не применяют сами.
last = None
for _ in range(90):
try:
with psycopg.connect(conninfo, connect_timeout=POOL_TIMEOUT_SECONDS, row_factory=dict_row) as conn:
row = conn.execute(
"SELECT 1 FROM schema_migrations WHERE version = %s",
(SCHEMA_VERSION,),
).fetchone()
if row is not None:
return
last = "migration missing"
except psycopg.Error as exc:
last = type(exc).__name__
time.sleep(1)
LOGGER.error("schema not ready: %s", last)
raise SystemExit(1)
def _wait_bucket(self):
from blobs import bucket_ready
for _ in range(60):
if bucket_ready():
return
time.sleep(1)
LOGGER.error("object storage not ready")
raise SystemExit(1)
def _connect(self):
try:
return self.pool.connection(timeout=POOL_TIMEOUT_SECONDS)
except PoolTimeout as exc:
_db_down(exc)
def create_user(self, username, display_name, password):
password_hash = hash_password(password)
user_id = uuid.uuid4()
created = utc_now()
try:
with self._connect() as conn:
with conn.transaction():
row = conn.execute(
"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (%s, %s, %s, %s, %s)
ON CONFLICT (username) DO NOTHING
RETURNING id, username, display_name, created_at
""",
(user_id, username, display_name, password_hash, created),
).fetchone()
except psycopg.OperationalError as exc:
_db_down(exc)
if row is None:
return None
return public_user(row)
def login(self, username, password):
try:
with self._connect() as conn:
row = conn.execute(
"""
SELECT id, username, display_name, password_hash, created_at
FROM users
WHERE username = %s
""",
(username,),
).fetchone()
except psycopg.OperationalError as exc:
_db_down(exc)
if row is None:
verify_password(password, DUMMY_HASH)
return None
if not verify_password(password, row["password_hash"]):
return None
return self._issue(public_user(row))
def _issue(self, user):
token = secrets.token_urlsafe(32)
expires = utc_now() + timedelta(seconds=self.ttl)
payload = json.dumps(
{"user_id": user["id"], "expires_at": dump_time(expires)},
separators=(",", ":"),
)
# pxat — абсолютное время. Рестарт Redis не сдвигает срок.
# В значении тоже лежит expires_at: даже если TTL ключа разъедется, сессия кончится вовремя.
try:
self.redis.set(session_key(token), payload, pxat=int(expires.timestamp() * 1000))
except redis.RedisError as exc:
raise DependencyDown() from exc
return {
"token": token,
"token_type": "Bearer",
"expires_at": dump_time(expires),
"user": user,
}
def user_for_token(self, token):
key = session_key(token)
try:
raw = self.redis.get(key)
except redis.RedisError as exc:
raise DependencyDown() from exc
if not raw:
return None
try:
payload = json.loads(raw)
expires = parse_time(payload["expires_at"])
user_id = payload["user_id"]
uuid.UUID(user_id)
except (ValueError, KeyError, TypeError):
return None
if utc_now() >= expires:
try:
self.redis.delete(key)
except redis.RedisError as exc:
raise DependencyDown() from exc
return None
try:
with self._connect() as conn:
row = conn.execute(
"""
SELECT id, username, display_name, created_at
FROM users
WHERE id = %s
""",
(user_id,),
).fetchone()
except psycopg.OperationalError as exc:
_db_down(exc)
if row is None:
return None
return public_user(row)
def revoke(self, token):
try:
deleted = self.redis.delete(session_key(token))
except redis.RedisError as exc:
raise DependencyDown() from exc
return deleted == 1
def create_chat(self, title, member_ids, caller_id):
try:
caller_uuid = uuid.UUID(str(caller_id))
member_uuids = []
seen = set()
for item in member_ids:
member_uuid = uuid.UUID(str(item))
if member_uuid in seen:
raise ValueError("members")
seen.add(member_uuid)
member_uuids.append(member_uuid)
except ValueError as exc:
raise ValueError("members") from exc
if caller_uuid not in seen:
raise ValueError("members")
chat_id = uuid.uuid4()
created = utc_now()
canonical_members = [str(item) for item in member_uuids]
try:
with self._connect() as conn:
try:
with conn.transaction():
conn.execute(
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)",
(chat_id, title, created),
)
for ordinal, member_id in enumerate(member_uuids):
conn.execute(
"""
INSERT INTO chat_members (chat_id, user_id, ordinal)
VALUES (%s, %s, %s)
""",
(chat_id, member_id, ordinal),
)
row = conn.execute(
"SELECT id, title, created_at FROM chats WHERE id = %s",
(chat_id,),
).fetchone()
except ForeignKeyViolation as exc:
raise ValueError("members") from exc
except UniqueViolation as exc:
raise ValueError("members") from exc
except psycopg.OperationalError as exc:
_db_down(exc)
return public_chat(row, canonical_members)
def _member(self, conn, chat_id, user_id):
return conn.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id, user_id),
).fetchone()
def get_chat(self, chat_id, user_id):
try:
with self._connect() as conn:
if self._member(conn, chat_id, user_id) is None:
return None
row = conn.execute(
"""
SELECT c.id, c.title, c.created_at,
array_agg(m.user_id ORDER BY m.ordinal) AS member_ids
FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE c.id = %s
GROUP BY c.id
""",
(chat_id,),
).fetchone()
except psycopg.OperationalError as exc:
_db_down(exc)
if row is None:
return None
return public_chat(row)
def list_chats(self, user_id, limit, cursor):
after = None
if cursor is not None:
created_at, item_id = decode_cursor(cursor, "chats:" + user_id)
after = (parse_time(created_at), uuid.UUID(item_id))
sql = """
SELECT c.id, c.title, c.created_at,
array_agg(m.user_id ORDER BY m.ordinal) AS member_ids
FROM chats c
JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = %s
JOIN chat_members m ON m.chat_id = c.id
"""
params = [user_id]
if after is not None:
sql += " WHERE (c.created_at, c.id) > (%s, %s)"
params.extend(after)
sql += " GROUP BY c.id ORDER BY c.created_at, c.id LIMIT %s"
params.append(limit + 1)
try:
with self._connect() as conn:
rows = conn.execute(sql, params).fetchall()
except psycopg.OperationalError as exc:
_db_down(exc)
page = [public_chat(row) for row in rows[:limit]]
if len(rows) > limit and page:
last = page[-1]
return page, encode_cursor("chats:" + user_id, last["created_at"], last["id"])
return page, None
def _attachment_ids(self, conn, message_ids):
if not message_ids:
return {}
rows = conn.execute(
"""
SELECT message_id, attachment_id
FROM message_attachments
WHERE message_id = ANY(%s::uuid[])
ORDER BY ordinal
""",
(list(message_ids),),
).fetchall()
found = {}
for row in rows:
found.setdefault(str(row["message_id"]), []).append(str(row["attachment_id"]))
return found
def is_member(self, chat_id, user_id):
try:
with self._connect() as conn:
return self._member(conn, chat_id, user_id) is not None
except psycopg.OperationalError as exc:
_db_down(exc)
def save_attachment(self, chat_id, owner_id, filename, content_type, data):
from blobs import delete_quiet, object_key, put_bytes
attachment_id = uuid.uuid4()
key = object_key(chat_id, attachment_id)
digest = hashlib.sha256(data).hexdigest()
created = utc_now()
put_bytes(key, data, content_type, created)
try:
with self._connect() as conn:
with conn.transaction():
if self._member(conn, chat_id, owner_id) is None:
raise LookupError("chat")
row = conn.execute(
"""
INSERT INTO attachments (
id, chat_id, owner_id, filename, content_type,
size_bytes, sha256, object_key, status, created_at, updated_at
)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, 'ready', %s, %s)
RETURNING id, chat_id, owner_id, filename, content_type,
size_bytes, sha256, created_at, updated_at
""",
(
attachment_id,
chat_id,
owner_id,
filename,
content_type,
len(data),
digest,
key,
created,
created,
),
).fetchone()
except (LookupError, ForeignKeyViolation):
delete_quiet(key)
return None
except psycopg.OperationalError as exc:
delete_quiet(key)
_db_down(exc)
except Exception:
delete_quiet(key)
raise
return public_attachment(row)
def get_attachment(self, attachment_id, user_id):
try:
with self._connect() as conn:
row = conn.execute(
"""
SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type,
a.size_bytes, a.sha256, a.created_at, a.updated_at
FROM attachments a
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = %s
WHERE a.id = %s
""",
(user_id, attachment_id),
).fetchone()
except psycopg.OperationalError as exc:
_db_down(exc)
if row is None:
return None
return public_attachment(row)
def open_attachment(self, attachment_id, user_id):
try:
with self._connect() as conn:
row = conn.execute(
"""
SELECT a.object_key, a.content_type, a.size_bytes
FROM attachments a
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = %s
WHERE a.id = %s
""",
(user_id, attachment_id),
).fetchone()
except psycopg.OperationalError as exc:
_db_down(exc)
if row is None:
return None
return {
"object_key": row["object_key"],
"content_type": row["content_type"],
"size_bytes": int(row["size_bytes"]),
}
def add_message(self, chat_id, sender_id, text, idem_key, attachment_ids):
# Один ключ сериализуется между репликами через advisory lock в той же
# транзакции, где INSERT сообщения. Откат не оставляет ключ занятым.
path = chat_path(chat_id)
digest = message_fingerprint(text, attachment_ids)
lock_key = advisory_key(sender_id, path, idem_key)
message_id = uuid.uuid4()
try:
with self._connect() as conn:
with conn.transaction():
# Иначе lock_timeout сессии (3 с) оборвёт очередь одинаковых ключей.
conn.execute("SET LOCAL lock_timeout = '15s'")
conn.execute("SELECT pg_advisory_xact_lock(%s)", (lock_key,))
if self._member(conn, chat_id, sender_id) is None:
return None
existing = conn.execute(
"""
SELECT request_hash, message_id,
created_at >= now() - make_interval(secs => %s) AS fresh
FROM idempotency_keys
WHERE user_id = %s AND http_method = 'POST'
AND request_path = %s AND idem_key = %s
""",
(self.idem_ttl, sender_id, path, idem_key),
).fetchone()
if existing is not None and existing["fresh"]:
if existing["request_hash"] != digest:
raise IdempotencyConflict()
row = conn.execute(SQL_MESSAGE_BY_ID, (existing["message_id"],)).fetchone()
if row is None:
raise RuntimeError("idempotency target missing")
linked = self._attachment_ids(conn, [row["id"]]).get(str(row["id"]), [])
return public_message(row, linked)
if existing is not None:
conn.execute(
"""
DELETE FROM idempotency_keys
WHERE user_id = %s AND http_method = 'POST'
AND request_path = %s AND idem_key = %s
""",
(sender_id, path, idem_key),
)
if attachment_ids:
found = conn.execute(
"""
SELECT id, chat_id, status
FROM attachments
WHERE id = ANY(%s::uuid[])
""",
(list(attachment_ids),),
).fetchall()
by_id = {str(item["id"]): item for item in found}
for attachment_id in attachment_ids:
item = by_id.get(attachment_id)
if item is None or str(item["chat_id"]) != chat_id:
return None
if item["status"] != "ready":
raise AttachmentRejected()
row = conn.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, body, created_at)
VALUES (%s, %s, %s, %s, clock_timestamp())
RETURNING id, chat_id, sender_id, body AS text, created_at
""",
(message_id, chat_id, sender_id, text),
).fetchone()
for ordinal, attachment_id in enumerate(attachment_ids):
conn.execute(
"""
INSERT INTO message_attachments (message_id, attachment_id, ordinal)
VALUES (%s, %s, %s)
""",
(row["id"], attachment_id, ordinal),
)
conn.execute(
"""
INSERT INTO idempotency_keys (
user_id, http_method, request_path, idem_key,
request_hash, message_id, created_at
)
VALUES (%s, 'POST', %s, %s, %s, %s, clock_timestamp())
""",
(sender_id, path, idem_key, digest, row["id"]),
)
return public_message(row, attachment_ids)
except CheckViolation as exc:
raise ValueError("message") from exc
except psycopg.OperationalError as exc:
_db_down(exc)
def list_messages(self, chat_id, user_id, limit, cursor):
after = None
if cursor is not None:
created_at, item_id = decode_cursor(cursor, chat_id)
after = (parse_time(created_at), uuid.UUID(item_id))
try:
with self._connect() as conn:
if self._member(conn, chat_id, user_id) is None:
return None
if after is None:
rows = conn.execute(SQL_MESSAGES_FIRST, (chat_id, limit + 1)).fetchall()
else:
rows = conn.execute(
SQL_MESSAGES_AFTER,
(chat_id, after[0], after[1], limit + 1),
).fetchall()
linked = self._attachment_ids(conn, [row["id"] for row in rows[:limit]])
except psycopg.OperationalError as exc:
_db_down(exc)
page = [public_message(row, linked.get(str(row["id"]), [])) for row in rows[:limit]]
if len(rows) > limit and page:
last = page[-1]
return page, encode_cursor(chat_id, last["created_at"], last["id"])
return page, None
+212
View File
@@ -0,0 +1,212 @@
"""Один прогон трека 2: сухие планы, применение, повтор и проверка живых файлов.
Запускать внутри API-контейнера: там есть ключ bucket и строка подключения,
а наружу они не печатаются.
"""
import base64
import json
import urllib.error
import urllib.request
import uuid
from datetime import datetime, timedelta, timezone
from io import BytesIO
import psycopg
from minio import Minio
from PIL import Image
from blobs import BUCKET, read_secret
from reconcile import plan
BASE = "http://127.0.0.1:8080"
def call(method, path, body=None, token=None, raw=None, content_type=None, status=200):
data = raw
headers = {}
if body is not None:
data = json.dumps(body).encode("utf-8")
headers["Content-Type"] = "application/json"
if raw is not None:
headers["Content-Type"] = content_type
if token:
headers["Authorization"] = "Bearer " + token
if method == "POST" and path.endswith("/messages"):
headers["Idempotency-Key"] = uuid.uuid4().hex
request = urllib.request.Request(BASE + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(request, timeout=30) as response:
payload = response.read()
code = response.status
mime = response.headers.get("Content-Type", "")
except urllib.error.HTTPError as exc:
payload = exc.read()
code = exc.status
mime = exc.headers.get("Content-Type", "")
if code != status:
raise SystemExit("expected {} got {} for {} {}".format(status, code, method, path))
if "application/json" in mime:
return json.loads(payload.decode("utf-8"))
return payload
def user():
name = "u" + uuid.uuid4().hex[:12]
password = "pw-" + uuid.uuid4().hex
created = call("POST", "/api/v1/users", {"username": name, "password": password, "display_name": name}, status=201)
basic = base64.b64encode((name + ":" + password).encode("utf-8")).decode("ascii")
request = urllib.request.Request(
BASE + "/api/v1/auth/sessions",
data=b"",
headers={"Authorization": "Basic " + basic},
method="POST",
)
with urllib.request.urlopen(request, timeout=30) as response:
session = json.loads(response.read().decode("utf-8"))
return created, session["token"]
def png(color):
image = Image.new("RGB", (32, 24), color)
buffer = BytesIO()
image.save(buffer, "PNG")
return buffer.getvalue()
def upload(token, chat_id, data, filename):
return call(
"POST",
"/api/v1/chats/" + chat_id + "/attachments?filename=" + filename,
token=token,
raw=data,
content_type="image/png",
status=201,
)
def main():
alice, alice_token = user()
bob, bob_token = user()
chat = call(
"POST",
"/api/v1/chats",
{"title": "track2", "member_ids": [alice["id"], bob["id"]]},
token=alice_token,
status=201,
)
picture_a = png((255, 0, 0))
picture_b = png((0, 255, 0))
picture_c = png((0, 0, 255))
picture_d = png((255, 255, 0))
attachment_a = upload(alice_token, chat["id"], picture_a, "used.png")
attachment_b = upload(alice_token, chat["id"], picture_b, "fresh.png")
attachment_c = upload(alice_token, chat["id"], picture_c, "stale.png")
attachment_d = upload(alice_token, chat["id"], picture_d, "linked-missing.png")
call(
"POST",
"/api/v1/chats/" + chat["id"] + "/messages",
{"text": "", "attachment_ids": [attachment_a["id"]]},
token=alice_token,
status=201,
)
call(
"POST",
"/api/v1/chats/" + chat["id"] + "/messages",
{"text": "used-missing", "attachment_ids": [attachment_d["id"]]},
token=alice_token,
status=201,
)
endpoint = "minio:9000"
storage = Minio(
endpoint,
access_key=read_secret("/run/secrets/s3_access_key"),
secret_key=read_secret("/run/secrets/s3_secret_key"),
secure=False,
)
with psycopg.connect(open("/run/secrets/database_url", encoding="utf-8").read().strip()) as conn:
keys = dict(conn.execute(
"SELECT id::text, object_key FROM attachments WHERE id = ANY(%s::uuid[])",
([attachment_c["id"], attachment_d["id"]],),
).fetchall())
conn.execute(
"""
UPDATE attachments
SET created_at = now() - interval '2 hours',
updated_at = now() - interval '2 hours'
WHERE id = ANY(%s::uuid[])
""",
([attachment_c["id"], attachment_d["id"]],),
)
conn.commit()
storage.remove_object(BUCKET, keys[attachment_c["id"]])
storage.remove_object(BUCKET, keys[attachment_d["id"]])
old_key = "chats/" + chat["id"] + "/attachments/" + str(uuid.uuid4()) + "/original"
fresh_key = "chats/" + chat["id"] + "/attachments/" + str(uuid.uuid4()) + "/original"
old_stamp = (datetime.now(timezone.utc) - timedelta(hours=2)).strftime("%Y-%m-%dT%H:%M:%SZ")
fresh_stamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
storage.put_object(
BUCKET, old_key, BytesIO(b"old-orphan"), 10, metadata={"created-at": old_stamp}
)
storage.put_object(
BUCKET, fresh_key, BytesIO(b"fresh-orphan"), 12, metadata={"created-at": fresh_stamp}
)
before = plan(120)
from reconcile import apply_plan
applied = apply_plan(dict(before))
after = plan(120)
downloaded_a = call("GET", "/api/v1/attachments/" + attachment_a["id"] + "/content", token=bob_token)
downloaded_b = call("GET", "/api/v1/attachments/" + attachment_b["id"] + "/content", token=bob_token)
call("GET", "/api/v1/attachments/" + attachment_d["id"], token=bob_token)
call("GET", "/api/v1/attachments/" + attachment_d["id"] + "/content", token=bob_token, status=404)
call("GET", "/api/v1/attachments/" + attachment_c["id"], token=bob_token, status=404)
try:
storage.stat_object(BUCKET, old_key)
old_gone = False
except Exception:
old_gone = True
try:
storage.stat_object(BUCKET, fresh_key)
fresh_kept = True
except Exception:
fresh_kept = False
delete_actions = [item["action"] for item in before["actions"]]
report = {
"dry_run_actions": delete_actions,
"applied_objects": applied.get("deleted_objects"),
"applied_rows": applied.get("deleted_rows"),
"second_run_actions": [item["action"] for item in after["actions"]],
"list_seconds": before["list_seconds"],
"objects_seen": before["objects"],
"rows_seen": before["rows"],
"preserved_reasons": sorted({item["reason"] for item in before["preserved"]}),
"used_file_same": downloaded_a == picture_a,
"fresh_file_same": downloaded_b == picture_b,
"old_orphan_removed": old_gone,
"fresh_orphan_kept": fresh_kept,
"in_use_missing_preserved": any(
item.get("attachment_id") == attachment_d["id"] for item in after["preserved"]
),
}
print(json.dumps(report, ensure_ascii=False, sort_keys=True))
checks = [
"delete_orphan_object" in delete_actions,
"delete_orphan_row" in delete_actions,
report["second_run_actions"] == [],
report["used_file_same"] and report["fresh_file_same"],
report["old_orphan_removed"] and report["fresh_orphan_kept"],
report["in_use_missing_preserved"],
"fresh_object" in report["preserved_reasons"],
"missing_but_in_use" in report["preserved_reasons"],
]
if not all(checks):
raise SystemExit(1)
if __name__ == "__main__":
main()
+230
View File
@@ -0,0 +1,230 @@
"""Негативные случаи вложений, память десяти загрузок и закрытый bucket.
Сервер уже должен слушать http://127.0.0.1:8080. Секреты скрипт не печатает.
"""
import base64
import json
import os
import struct
import subprocess
import threading
import time
import urllib.error
import urllib.request
import uuid
import zlib
from pathlib import Path
BASE = "http://127.0.0.1:8080"
ROOT = Path(__file__).resolve().parents[1]
MAX_BYTES = 10 * 1024 * 1024
def call(method, path, body=None, token=None, raw=None, content_type=None, status=None, headers=None):
data = raw
sent = dict(headers or {})
if body is not None:
data = json.dumps(body).encode("utf-8")
sent["Content-Type"] = "application/json"
if content_type:
sent["Content-Type"] = content_type
if token:
sent["Authorization"] = "Bearer " + token
request = urllib.request.Request(BASE + path, data=data, headers=sent, method=method)
try:
with urllib.request.urlopen(request, timeout=60) as response:
payload = response.read()
code = response.status
response_headers = response.headers
except urllib.error.HTTPError as exc:
payload = exc.read()
code = exc.status
response_headers = exc.headers
if status is not None and code != status:
raise SystemExit("{} {} -> {} expected {}\n{}".format(method, path, code, status, payload[:300]))
parsed = None
if response_headers.get_content_type() == "application/json" and payload:
parsed = json.loads(payload.decode("utf-8"))
return {"status": code, "json": parsed, "bytes": payload, "headers": response_headers}
def user(prefix):
name = prefix + uuid.uuid4().hex[:10]
password = "password-" + uuid.uuid4().hex
created = call("POST", "/api/v1/users", {"username": name, "password": password, "display_name": name}, status=201)["json"]
basic = base64.b64encode((name + ":" + password).encode()).decode("ascii")
session = call("POST", "/api/v1/auth/sessions", token=None, headers={"Authorization": "Basic " + basic}, status=201)["json"]
created["token"] = session["token"]
return created
def chat(owner, *members):
return call(
"POST",
"/api/v1/chats",
{"title": "files", "member_ids": [owner["id"], *[item["id"] for item in members]]},
token=owner["token"],
status=201,
)["json"]
def png_chunk(tag, data):
return struct.pack(">I", len(data)) + tag + data + struct.pack(">I", zlib.crc32(tag + data) & 0xFFFFFFFF)
def tiny_png():
raw = b"\x00\xff\x00\x00"
return (
b"\x89PNG\r\n\x1a\n"
+ png_chunk(b"IHDR", struct.pack(">IIBBBBB", 1, 1, 8, 2, 0, 0, 0))
+ png_chunk(b"IDAT", zlib.compress(raw))
+ png_chunk(b"IEND", b"")
)
def noisy_png(width, height):
rows = bytearray()
for _ in range(height):
rows.append(0)
rows.extend(os.urandom(width * 3))
return (
b"\x89PNG\r\n\x1a\n"
+ png_chunk(b"IHDR", struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0))
+ png_chunk(b"IDAT", zlib.compress(bytes(rows), 1))
+ png_chunk(b"IEND", b"")
)
def huge_header():
return (
b"\x89PNG\r\n\x1a\n"
+ png_chunk(b"IHDR", struct.pack(">IIBBBBB", 8000, 8000, 8, 2, 0, 0, 0))
+ png_chunk(b"IEND", b"")
)
def upload(token, chat_id, data, filename="a.png", content_type="image/png", status=201):
return call(
"POST",
"/api/v1/chats/{}/attachments?filename={}".format(chat_id, urllib.request.quote(filename)),
token=token,
raw=data,
content_type=content_type,
status=status,
)
def message(token, chat_id, text, attachments, status=201, key=None):
headers = {"Idempotency-Key": key or uuid.uuid4().hex}
return call(
"POST",
"/api/v1/chats/" + chat_id + "/messages",
{"text": text, "attachment_ids": attachments},
token=token,
status=status,
headers=headers,
)
def main():
picture = tiny_png()
alice = user("fa")
bob = user("fb")
eve = user("fe")
room = chat(alice, bob)
other = chat(alice, bob)
saved = upload(alice["token"], room["id"], picture)["json"]
if saved["status"] != "ready" or saved["sha256"] != __import__("hashlib").sha256(picture).hexdigest():
raise SystemExit("checksum")
if saved["filename"] != "a.png" or "object_key" in saved or saved["content_type"] != "image/png":
raise SystemExit("filename leaked into key fields")
linked = message(alice["token"], room["id"], "", [saved["id"]])["json"]
if linked["attachment_ids"] != [saved["id"]]:
raise SystemExit("link")
downloaded = call("GET", "/api/v1/attachments/" + saved["id"] + "/content", token=bob["token"])
if downloaded["bytes"] != picture or downloaded["headers"].get_content_type() != "image/png":
raise SystemExit("download")
if downloaded["headers"].get("Location"):
raise SystemExit("redirect")
call("GET", "/api/v1/attachments/" + saved["id"], token=eve["token"], status=404)
call("GET", "/api/v1/attachments/" + saved["id"] + "/content", token=eve["token"], status=404)
call("GET", "/api/v1/attachments/" + saved["id"] + "/content?variant=thumbnail", token=bob["token"], status=404)
upload(eve["token"], room["id"], picture, status=404)
upload(alice["token"], room["id"], picture, filename="../x.png", status=400)
upload(alice["token"], room["id"], picture, filename="a\\b.png", status=400)
upload(alice["token"], room["id"], picture, filename="bad\nname.png", status=400)
upload(alice["token"], room["id"], b"\x89PNG\r\n\x1a\nbroken", status=415)
upload(alice["token"], room["id"], picture, content_type="image/jpeg", status=415)
upload(alice["token"], room["id"], picture, content_type="text/plain", status=415)
upload(alice["token"], room["id"], huge_header(), status=413)
upload(alice["token"], room["id"], b"x" * (MAX_BYTES + 1), status=413)
foreign = upload(alice["token"], other["id"], picture)["json"]
message(alice["token"], room["id"], "x", [foreign["id"]], status=404)
message(alice["token"], room["id"], "x", [str(uuid.uuid4())], status=404)
message(alice["token"], room["id"], " ", [], status=400)
message(alice["token"], room["id"], "", [], status=400)
call("POST", "/api/v1/chats/" + room["id"] + "/attachments?filename=a.png", raw=picture, content_type="image/png", status=401)
same = uuid.uuid4().hex
first = message(alice["token"], room["id"], "same", [saved["id"]], key=same)["json"]
replay = message(alice["token"], room["id"], "same", [saved["id"]], key=same)["json"]
if replay != first:
raise SystemExit("replay")
message(alice["token"], room["id"], "other", [saved["id"]], key=same, status=409)
peaks = {}
stop = threading.Event()
def sample():
while not stop.is_set():
result = subprocess.run(
["docker", "stats", "--no-stream", "--format", "{{.Name}} {{.MemUsage}}"],
capture_output=True,
text=True,
check=False,
)
for line in result.stdout.splitlines():
if "mtusi-lab4-api" not in line:
continue
name, usage = line.split()[:2]
number = usage.replace("MiB", "").replace("GiB", "")
try:
value = float(number)
except ValueError:
continue
if usage.endswith("GiB"):
value *= 1024
peaks[name] = max(peaks.get(name, 0), value)
time.sleep(0.2)
thread = threading.Thread(target=sample)
thread.start()
errors = []
wide = noisy_png(640, 480)
def once():
try:
upload(alice["token"], room["id"], wide, filename="batch.png")
except SystemExit as exc:
errors.append(str(exc))
workers = [threading.Thread(target=once) for _ in range(10)]
for worker in workers:
worker.start()
for worker in workers:
worker.join()
stop.set()
thread.join()
if errors:
raise SystemExit("concurrent " + errors[0])
print(json.dumps({
"concurrent_uploads": 10,
"upload_bytes": len(wide),
"peak_mib": peaks,
"limit_mib": 256,
}, ensure_ascii=False))
print("PASS files")
if __name__ == "__main__":
main()