diff --git a/.env.example b/.env.example index d99d26a2..b34c426d 100644 --- a/.env.example +++ b/.env.example @@ -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 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..fe560927 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,4 @@ +*.sh text eol=lf +*.cfg text eol=lf +Dockerfile text eol=lf +*.sql text eol=lf diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 1bec5472..28aa0884 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -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 содержит инструкцию именно моего решения. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..f1b9d26b --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..20c634ad 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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//attachments//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 закреплён. Новые уязвимости этого выпуска я отдельно не проверяла. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..17494c0f --- /dev/null +++ b/compose.yaml @@ -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 diff --git a/evidence/failover.txt b/evidence/failover.txt new file mode 100644 index 00000000..1c321459 --- /dev/null +++ b/evidence/failover.txt @@ -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. diff --git a/evidence/files.json b/evidence/files.json new file mode 100644 index 00000000..8c3e9b80 --- /dev/null +++ b/evidence/files.json @@ -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" + ] +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..27756122 --- /dev/null +++ b/evidence/persistence.txt @@ -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. diff --git a/evidence/private.txt b/evidence/private.txt new file mode 100644 index 00000000..9195aa63 --- /dev/null +++ b/evidence/private.txt @@ -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. diff --git a/evidence/track2.json b/evidence/track2.json new file mode 100644 index 00000000..356edb91 --- /dev/null +++ b/evidence/track2.json @@ -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 +} diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 00000000..94f7d800 --- /dev/null +++ b/infra/haproxy.cfg @@ -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 diff --git a/infra/minio-api-policy.json b/infra/minio-api-policy.json new file mode 100644 index 00000000..cfef8ef8 --- /dev/null +++ b/infra/minio-api-policy.json @@ -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"] + } + ] +} diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..994fa1d1 --- /dev/null +++ b/migrations/001_init.sql @@ -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); diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..d4e557b5 --- /dev/null +++ b/migrations/002_idempotency.sql @@ -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) +); diff --git a/migrations/003_attachments.sql b/migrations/003_attachments.sql new file mode 100644 index 00000000..ebb52e38 --- /dev/null +++ b/migrations/003_attachments.sql @@ -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); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..4f78b790 --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/scripts/bootstrap.py b/scripts/bootstrap.py new file mode 100644 index 00000000..1909ed2e --- /dev/null +++ b/scripts/bootstrap.py @@ -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()) diff --git a/scripts/minio-init.sh b/scripts/minio-init.sh new file mode 100755 index 00000000..5685ff3b --- /dev/null +++ b/scripts/minio-init.sh @@ -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" diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..26891c7d --- /dev/null +++ b/scripts/restart.sh @@ -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 diff --git a/scripts/rolling-restart.sh b/scripts/rolling-restart.sh new file mode 100755 index 00000000..a9b45a5f --- /dev/null +++ b/scripts/rolling-restart.sh @@ -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 diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..d4872e3d --- /dev/null +++ b/scripts/stop-one.sh @@ -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 diff --git a/scripts/wait_ready.py b/scripts/wait_ready.py new file mode 100644 index 00000000..dd556dca --- /dev/null +++ b/scripts/wait_ready.py @@ -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()) diff --git a/src/blobs.py b/src/blobs.py new file mode 100644 index 00000000..4d70f45e --- /dev/null +++ b/src/blobs.py @@ -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 diff --git a/src/errors.py b/src/errors.py new file mode 100644 index 00000000..296f1c59 --- /dev/null +++ b/src/errors.py @@ -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, + } + } diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..aabcfa58 --- /dev/null +++ b/src/main.py @@ -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, + ) diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..cc35b87c --- /dev/null +++ b/src/migrate.py @@ -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()) diff --git a/src/passwords.py b/src/passwords.py new file mode 100644 index 00000000..67c8daa2 --- /dev/null +++ b/src/passwords.py @@ -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 diff --git a/src/reconcile.py b/src/reconcile.py new file mode 100644 index 00000000..394b6081 --- /dev/null +++ b/src/reconcile.py @@ -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()) diff --git a/src/schemas.py b/src/schemas.py new file mode 100644 index 00000000..e11752d8 --- /dev/null +++ b/src/schemas.py @@ -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 diff --git a/src/store.py b/src/store.py new file mode 100644 index 00000000..0be28706 --- /dev/null +++ b/src/store.py @@ -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 diff --git a/src/track2_demo.py b/src/track2_demo.py new file mode 100644 index 00000000..556bd07f --- /dev/null +++ b/src/track2_demo.py @@ -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() diff --git a/student-tests/run_files.py b/student-tests/run_files.py new file mode 100644 index 00000000..224d5703 --- /dev/null +++ b/student-tests/run_files.py @@ -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()