Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
007da711ba |
+15
-16
@@ -1,20 +1,19 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
APP_HOST=0.0.0.0
|
||||
# Copy to .env and replace every CHANGE-ME value. Never commit .env.
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
POSTGRES_USER=messenger
|
||||
POSTGRES_PASSWORD=CHANGE-ME-postgres-long-random-secret
|
||||
POSTGRES_DB=messenger
|
||||
CURSOR_SECRET=CHANGE-ME-random-32-byte-secret
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
S3_ENDPOINT=http://s3:9000
|
||||
S3_REGION=us-east-1
|
||||
DB_POOL_MAX=10
|
||||
DB_POOL_MIN=1
|
||||
API_CPUS=1.0
|
||||
API_MEMORY=512m
|
||||
LB_CPUS=0.25
|
||||
RUSTFS_ROOT_ACCESS_KEY=MESSENGERADMIN
|
||||
RUSTFS_ROOT_SECRET_KEY=CHANGE-ME-rustfs-root-long-secret
|
||||
S3_API_ACCESS_KEY=MESSENGERAPI
|
||||
S3_API_SECRET_KEY=CHANGE-ME-s3-api-long-secret
|
||||
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
|
||||
UPLOAD_CONCURRENCY=2
|
||||
|
||||
@@ -1,18 +1,18 @@
|
||||
## Лабораторная 4
|
||||
|
||||
Автор / группа: TODO
|
||||
Целевая оценка (3/4/5): TODO
|
||||
Трек 5, если заявлен: TODO
|
||||
Автор / группа: Койчакаев Багавдин / БВТ2301
|
||||
Целевая оценка (3/4/5): 5
|
||||
Трек 5, если заявлен: трек 2 — сверка PostgreSQL/S3
|
||||
|
||||
Что реализовано и что перенесено: TODO
|
||||
Команды запуска из чистого clone: TODO
|
||||
Результаты проверок и ссылка на REPORT.md: TODO
|
||||
Ограничения / известные ошибки: TODO
|
||||
Источники и использование ИИ: TODO
|
||||
Что реализовано и что перенесено: API, auth/session, pagination, idempotency и LB из lab3; RustFS private bucket, metadata migrations, bounded PNG/JPEG upload/download, message attachment ACL, compensating delete, orphan/missing reconciliation с dry-run и grace period.
|
||||
Команды запуска из чистого clone: `make check`; `scripts/init-env.sh`; `docker compose --env-file .env up -d --build --scale api=2`; `make test BASE_URL=http://127.0.0.1:8080`.
|
||||
Результаты проверок и ссылка на REPORT.md: PASS smoke, attachment negative cases, private bucket 403, S3 failure/compensation, 10 concurrent uploads, failover, persistence, reconciler fault injection. См. [REPORT.md](../REPORT.md) и `evidence/`.
|
||||
Ограничения / известные ошибки: локальный одноузловой стенд без TLS; RustFS single-node не защищает от потери host/volume; burst — один локальный sample.
|
||||
Источники и использование ИИ: официальный RustFS container/IAM docs; boto3, Pillow, psycopg, Argon2; помощь Codex указана в REPORT.md.
|
||||
|
||||
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
|
||||
- [ ] Контракт и публичные тесты не ослаблены.
|
||||
- [ ] make check и make test выполнены; приложен реальный вывод.
|
||||
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
|
||||
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
|
||||
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
|
||||
- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
|
||||
- [x] Контракт и публичные тесты не ослаблены.
|
||||
- [x] `make check` и `make test` выполнены; приложен реальный вывод.
|
||||
- [x] Сценарии отказов/безопасности своего уровня воспроизведены.
|
||||
- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
|
||||
- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
|
||||
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
FROM python:3.12.8-slim-bookworm@sha256:2199a62885a12290dc9c5be3ca0681d367576ab7bf037da120e564723292a2f0
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PIP_DISABLE_PIP_VERSION_CHECK=1 PIP_DEFAULT_TIMEOUT=60 PIP_RETRIES=3
|
||||
WORKDIR /app
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt && groupadd --gid 10001 app && useradd --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app
|
||||
COPY --chown=app:app server.py ./server.py
|
||||
COPY --chown=app:app migrations ./migrations
|
||||
COPY --chown=app:app scripts/reconcile.py ./scripts/reconcile.py
|
||||
COPY --chown=app:app tests/reconcile_scenarios.py ./tests/reconcile_scenarios.py
|
||||
COPY --chown=app:app tests/private_bucket_check.py ./tests/private_bucket_check.py
|
||||
COPY --chown=app:app tests/reconcile_unit.py ./tests/reconcile_unit.py
|
||||
COPY --chown=app:app tests/s3_failure_probe.py ./tests/s3_failure_probe.py
|
||||
COPY --chown=app:app tests/fixtures/sample.png ./tests/fixtures/sample.png
|
||||
USER 10001:10001
|
||||
EXPOSE 8080
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=20s --retries=5 CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"
|
||||
CMD ["python", "server.py"]
|
||||
@@ -1,37 +1,78 @@
|
||||
# Отчёт — лабораторная 4
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Койчакаев Багавдин, БВТ2301
|
||||
- Целевая оценка: 5
|
||||
- Трек 5: трек 2 — согласованность PostgreSQL/S3
|
||||
- Commit/PR: решение подготовлено локально в клоне skeleton; публикация выполняется в личный fork по [CONTRIBUTING.md](CONTRIBUTING.md)
|
||||
- Источники, библиотеки и помощь ИИ: собственная реализация ЛР3; Python 3.12, psycopg, Argon2, boto3, Pillow; [RustFS container docs](https://docs.rustfs.com/en/installation/container), [RustFS IAM docs](https://docs.rustfs.com/en/security-compliance/iam); помощь Codex указана в этой строке.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Требуются Docker Desktop/Engine с Compose и Python 3.12 для локальных проверок. Стенд рассчитан на локальные синтетические данные; S3 API и Console не публикуются на хост. Compose закрепляет теги образов, Python закреплён digest в Dockerfile.
|
||||
|
||||
```sh
|
||||
make check
|
||||
scripts/init-env.sh # создаёт .env с уникальными секретами, режим 0600
|
||||
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build --scale api=2
|
||||
# ждать статуса healthy у api, postgres, valkey и haproxy:
|
||||
docker compose --env-file .env ps
|
||||
make test BASE_URL=http://127.0.0.1:8080
|
||||
```
|
||||
|
||||
При занятости 8080 задайте `APP_PORT` в `.env`; использованный локальный стенд работал на 18084. Для безопасной остановки без потери данных: `docker compose --env-file .env down`. Намеренно удалить учебные БД, сессии, вложения и volumes: `docker compose --env-file .env down -v`. В `.env` находятся локальные credentials; не добавлять его в Git.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```text
|
||||
Client → HAProxy → API × 2 → PostgreSQL (users/chats/messages/sessions/metadata)
|
||||
└→ private RustFS bucket (original bytes)
|
||||
```
|
||||
|
||||
Перенесены API, сессии, пагинация, идемпотентность и балансировка из ЛР3. `attachments` и `message_attachments` добавлены миграцией 003; составной FK не позволяет соединить сообщение и вложение разных чатов. PostgreSQL — источник истины для ACL и метаданных. Object key выдаёт сервер (`attachments/<uuid>`), а имя файла хранится отдельно и не попадает в ключ.
|
||||
|
||||
Загрузка ограничена 10 MiB и 40 млн пикселей. Тело читается порциями по 64 KiB во `SpooledTemporaryFile` (до 1 MiB в памяти, остаток во временном spool), проверяется SHA-256 и формат/декодирование, затем передаётся в S3. На API одновременно допускается не более двух обработок загрузки на реплику. Оригинал никогда не становится постоянным локальным файлом API. RustFS service использует named volume; bucket приватный. Root credentials используются только одноразовым bootstrap. API credential имеет ограниченную политику List/Get/Put/Delete только для bucket и prefix вложений. RustFS Console (9001) и S3 API (9000) доступны только внутри Compose network.
|
||||
|
||||
Граница двух хранилищ не является распределённой транзакцией. Сначала выполняется S3 PUT, затем транзакционная запись метаданных. При ошибке БД API компенсирует S3 PUT удалением; если удаление недоступно, ошибка записывается в log, а reconciler обнаружит объект без строки. Reconciler по умолчанию dry-run, минимальный grace period — 3600 секунд. Он постранично сравнивает S3 prefix и метаданные; отсутствующий объект переводит в `failed/object_missing`, старый S3-only объект удаляется только после grace period, старая metadata-only attachment удаляется только если нет связанного сообщения и повторная проверка под блокировкой подтверждает отсутствие ссылки. Свежие/используемые вложения не удаляются.
|
||||
|
||||
Версии Compose: API base `python:3.12.8-slim-bookworm` по digest, PostgreSQL `16.4-bookworm`, Valkey `8.0.1-alpine`, HAProxy `3.0.8-alpine`, RustFS `1.0.4`, RustFS CLI `v0.1.37`. Для restart/persistence volumes сохраняются.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| Критерий | Команда / сценарий | Результат | Доказательство |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Структура/контракт | `make check`; `make validate`; `python3 -m py_compile server.py scripts/reconcile.py tests/*.py`; `docker compose config --quiet` | PASS, контракт не изменён | `evidence/lab4-checks.txt` |
|
||||
| Публичный API | `make test BASE_URL=http://127.0.0.1:18084` | `PASS: lab4 public API scenario`; SHA-256/bytes совпали, участник скачал, outsider получил 404 | `evidence/lab4-checks.txt` |
|
||||
| Негативные вложения | `python3 tests/attachments_security.py ...` | 413 >10 MiB; 415 corrupt и MIME spoof; 400 unsafe filename; 404 чужой чат/пользователь | `evidence/lab4-checks.txt` |
|
||||
| Bucket приватный | `docker compose exec api python tests/private_bucket_check.py` | Anonymous ListBucket и прямой GetObject без API → 403; временный объект удалён | `evidence/lab4-checks.txt` |
|
||||
| S3/DB compensation | `tests/compensation_check.py` с инъекцией ошибки метаданных | API 503; compensating delete оставил S3 без orphan | `evidence/lab4-checks.txt` |
|
||||
| Отказ S3 | `python3 tests/s3_failure.py ...` | local API readiness и upload вернули 503; после старта RustFS readiness снова 200 | `evidence/lab4-checks.txt` |
|
||||
| Поток/память | `python3 tests/upload_burst.py ...` | 10 одновременных PNG × 7,684,003 B; 76,840,030 B всего; один sample 0.768 s, 95.46 MiB/s; cgroup `memory.peak`: API-1 162,799,616 B (155.3 MiB), API-2 162,144,256 B (154.5 MiB), лимит каждой реплики 512 MiB | `evidence/lab4-checks.txt` |
|
||||
| Failover | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh ...` | 115 подтверждённых writes, 1 временный сбой запроса, первый успешный ответ через 1.434 s; прежняя сессия и вложение сохранены | `evidence/lab4-checks.txt` |
|
||||
| Persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh ...` | API, HAProxy, PostgreSQL, Valkey и RustFS перезапущены без удаления volumes; данные, сессия и файл сохранились | `evidence/lab4-checks.txt` |
|
||||
| Трек 2: обе стороны | `docker compose exec api python tests/reconcile_scenarios.py` | Dry-run увидел missing metadata и S3 orphan; apply пометил missing как failed, свежий orphan и старое referenced вложение сохранил; повторный apply: 0 действий | `evidence/reconcile-scenarios.json` |
|
||||
| Трек 2: expired orphan | `docker compose exec api python tests/reconcile_unit.py` | Dry-run ничего не удалил; apply удалил двухдневный S3-only объект при grace=1h; повторный apply идемпотентен | `evidence/reconcile-unit.txt` |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
`make test` подтверждает контрактный HTTP сценарий, но сам по себе не выставляет оценку. Все сценарии выполнялись на локальном одноузловом Docker Desktop; измерения не являются production benchmark.
|
||||
|
||||
## Эксперименты и отказы
|
||||
## Эксперимент трека 2
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
**Гипотеза.** При сверке двух хранилищ без distributed transaction можно безопасно исправлять старые расхождения повторяемым проходом: не терять активно используемые/свежие файлы, делать `dry-run` без изменений и получать ноль дополнительных действий на повторном запуске.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
**Методика.** Сначала синтетический integration сценарий сохранил прежнее ready-вложение, вставил строку metadata без объекта, записал свежий S3-объект без metadata и искусственно состарил метаданные активного вложения. Запущены dry-run, apply, повторный apply. Отдельный детерминированный тест подменил S3 `LastModified` на два дня назад, чтобы проверить удаление orphan без ожидания реального часа. Не менялись публичные тесты/схемы. Выводы и время каждого прохода сохранены в `evidence/reconcile-scenarios.json` и `evidence/reconcile-unit.txt`.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
**Результат.** Missing object обнаружен и metadata переведена в failed; referenced объект остался; свежий объект, даже со старыми метаданными, был отложен grace period; старый orphan удалён только в apply; повторный проход не сделал действий. Сложность — полный листинг `attachments/` плюс линейный проход по rows PostgreSQL; на маленьком учебном наборе измеряется в миллисекундах, при большом bucket нужна метрика фактического размера и, возможно, инкрементальная сверка.
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
## Отказы и ограничения
|
||||
|
||||
Строгий smoke из репозитория ЛР3 отвергает дополнительное поле `attachment_ids` в объекте Message из-за `additionalProperties=false` в старой версии схемы. Это поле обязательно в контракте ЛР4; текстовый POST остаётся валидным, публичный smoke ЛР4 и отдельный тест конкурентной идемпотентности ЛР3 проходят. Старый строгий smoke и новый контракт одновременно требуют несовместимые формы одного ответа.
|
||||
|
||||
| Воздействие | Результат | Ограничение |
|
||||
| --- | --- | --- |
|
||||
| RustFS остановлен | readiness/upload 503; сервис восстановил readiness после старта | HAProxy снимает API-реплики из ротации, пока `ready` не пройдёт проверку |
|
||||
| PostgreSQL insert отклонён после S3 PUT | компенсирующий delete удалил объект | если сам delete недоступен, исправление отложено до reconciler и grace period |
|
||||
| API replica остановлена | подтверждённые данные читались через оставшуюся реплику; временно один запрос получил ошибку | один Docker host остаётся общей точкой отказа для LB, API, PostgreSQL, Valkey и RustFS |
|
||||
| Restart всех stateful services | данные и оригинал сохранились с named volumes | не проверяет потерю самого Docker host или volume |
|
||||
|
||||
RustFS запущен в single-node single-disk режиме: он даёт совместимость S3 API и персистентный volume для лабораторной, но не репликацию данных. Стенд предназначен только для локальных синтетических данных, использует HTTP на localhost и не включает TLS. Host/CPU модель отдельно не фиксировалась; burst измерен один раз и не является универсальным сравнением.
|
||||
|
||||
+116
@@ -0,0 +1,116 @@
|
||||
services:
|
||||
migrate:
|
||||
build: .
|
||||
command: ["python", "server.py"]
|
||||
environment:
|
||||
RUN_MIGRATIONS_ONLY: "1"
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@postgres:5432/${POSTGRES_DB:-messenger}
|
||||
depends_on:
|
||||
postgres: { condition: service_healthy }
|
||||
restart: "no"
|
||||
api:
|
||||
build: .
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: 8080
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
CURSOR_SECRET: ${CURSOR_SECRET:?Set CURSOR_SECRET in .env}
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@postgres:5432/${POSTGRES_DB:-messenger}
|
||||
CACHE_URL: redis://valkey:6379/0
|
||||
DB_POOL_MAX: ${DB_POOL_MAX:-10}
|
||||
DB_POOL_MIN: ${DB_POOL_MIN:-1}
|
||||
S3_ENDPOINT: http://rustfs:9000
|
||||
S3_REGION: us-east-1
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_ACCESS_KEY_ID: ${S3_API_ACCESS_KEY:?Set S3_API_ACCESS_KEY in .env}
|
||||
S3_SECRET_ACCESS_KEY: ${S3_API_SECRET_KEY:?Set S3_API_SECRET_KEY in .env}
|
||||
MAX_UPLOAD_BYTES: 10485760
|
||||
MAX_IMAGE_PIXELS: 40000000
|
||||
UPLOAD_CONCURRENCY: ${UPLOAD_CONCURRENCY:-2}
|
||||
depends_on:
|
||||
migrate: { condition: service_completed_successfully }
|
||||
valkey: { condition: service_healthy }
|
||||
bucket-bootstrap: { condition: service_completed_successfully }
|
||||
cpus: ${API_CPUS:-1.0}
|
||||
mem_limit: ${API_MEMORY:-512m}
|
||||
stop_grace_period: 10s
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 2
|
||||
start_period: 10s
|
||||
postgres:
|
||||
image: postgres:16.4-bookworm
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER:-messenger}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
|
||||
POSTGRES_DB: ${POSTGRES_DB:-messenger}
|
||||
volumes: ["postgres_data:/var/lib/postgresql/data"]
|
||||
cpus: 2.0
|
||||
mem_limit: 1g
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U \"$$POSTGRES_USER\" -d \"$$POSTGRES_DB\""]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
valkey:
|
||||
image: valkey/valkey:8.0.1-alpine
|
||||
restart: unless-stopped
|
||||
command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "everysec"]
|
||||
volumes: ["valkey_data:/data"]
|
||||
cpus: 0.25
|
||||
mem_limit: 128m
|
||||
healthcheck:
|
||||
test: ["CMD", "valkey-cli", "ping"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
rustfs:
|
||||
image: rustfs/rustfs:1.0.4
|
||||
restart: unless-stopped
|
||||
command: ["--address", ":9000", "--console-address", ":9001", "/data"]
|
||||
environment:
|
||||
RUSTFS_ACCESS_KEY: ${RUSTFS_ROOT_ACCESS_KEY:?Set RUSTFS_ROOT_ACCESS_KEY in .env}
|
||||
RUSTFS_SECRET_KEY: ${RUSTFS_ROOT_SECRET_KEY:?Set RUSTFS_ROOT_SECRET_KEY in .env}
|
||||
RUSTFS_ADDRESS: :9000
|
||||
RUSTFS_CONSOLE_ADDRESS: :9001
|
||||
RUSTFS_CONSOLE_ENABLE: "true"
|
||||
volumes: ["rustfs_data:/data"]
|
||||
expose: ["9000"]
|
||||
cpus: 1.0
|
||||
mem_limit: 512m
|
||||
bucket-bootstrap:
|
||||
image: rustfs/rc:v0.1.37
|
||||
entrypoint: ["/bin/sh", "/bootstrap/bootstrap.sh"]
|
||||
environment:
|
||||
RUSTFS_ROOT_ACCESS_KEY: ${RUSTFS_ROOT_ACCESS_KEY:?Set RUSTFS_ROOT_ACCESS_KEY in .env}
|
||||
RUSTFS_ROOT_SECRET_KEY: ${RUSTFS_ROOT_SECRET_KEY:?Set RUSTFS_ROOT_SECRET_KEY in .env}
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_API_ACCESS_KEY: ${S3_API_ACCESS_KEY:?Set S3_API_ACCESS_KEY in .env}
|
||||
S3_API_SECRET_KEY: ${S3_API_SECRET_KEY:?Set S3_API_SECRET_KEY in .env}
|
||||
volumes:
|
||||
- ./infra/rustfs-bootstrap.sh:/bootstrap/bootstrap.sh:ro
|
||||
- ./infra/rustfs-api-policy.json:/bootstrap/policy.json:ro
|
||||
depends_on:
|
||||
rustfs: { condition: service_started }
|
||||
restart: "no"
|
||||
haproxy:
|
||||
image: haproxy:3.0.8-alpine
|
||||
restart: unless-stopped
|
||||
ports: ["127.0.0.1:${APP_PORT:-8080}:8080"]
|
||||
volumes: ["./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro"]
|
||||
depends_on: [api]
|
||||
cpus: ${LB_CPUS:-0.25}
|
||||
mem_limit: 128m
|
||||
healthcheck:
|
||||
test: ["CMD", "haproxy", "-c", "-f", "/usr/local/etc/haproxy/haproxy.cfg"]
|
||||
interval: 10s
|
||||
timeout: 3s
|
||||
retries: 3
|
||||
volumes:
|
||||
postgres_data:
|
||||
valkey_data:
|
||||
rustfs_data:
|
||||
@@ -0,0 +1,30 @@
|
||||
Lab 4 local verification record
|
||||
Date: 2026-11-15
|
||||
Workspace: local Docker Compose, two API replicas, PostgreSQL, Valkey, HAProxy, private RustFS bucket
|
||||
|
||||
Structure and syntax
|
||||
- `make check PYTHON=python3`: PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
- `make validate PYTHON=.venv/bin/python`: PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
|
||||
- `python3 -m py_compile server.py scripts/reconcile.py tests/*.py`: PASS (exit 0).
|
||||
- `docker compose --env-file .env config --quiet`: PASS (exit 0).
|
||||
- `make test PYTHON=python3 BASE_URL=http://127.0.0.1:18084`: PASS: lab4 public API scenario.
|
||||
- Lab3 public smoke: fails its strict old `Message` schema on the additive `attachment_ids` response field; Lab4 requires that field, and the Lab4 public smoke plus lab3 idempotency-race test pass. Text-only POST requests remain accepted.
|
||||
|
||||
Attachment behavior and security
|
||||
- API scenario: upload/download SHA-256 and byte count matched; chat participant could download; outsider received 404.
|
||||
- Negative upload checks: >10 MiB -> 413; corrupt image and MIME spoof -> 415; unsafe filename -> 400; foreign chat/attachment access -> 404.
|
||||
- Direct RustFS checks outside the API: anonymous ListBucket -> HTTP 403 and anonymous GetObject for a temporary test object -> HTTP 403; temporary object removed in `finally`.
|
||||
- Injected database metadata failure after S3 PUT: API returned 503; compensating S3 delete left no orphan object.
|
||||
- RustFS outage: readiness and upload returned 503; after RustFS restart readiness returned 200.
|
||||
|
||||
Streaming and resilience
|
||||
- Upload burst: 10 concurrent PNG uploads x 7,684,003 bytes = 76,840,030 bytes; observed sample 0.768 s / 95.46 MiB/s.
|
||||
- API cgroup memory.peak: replica 1 = 162,799,616 B (155.3 MiB), replica 2 = 162,144,256 B (154.5 MiB), limit = 512 MiB per replica; no residual spool files found.
|
||||
- Failover: 115 confirmed writes, 1 transient failed request, first successful response after 1.434 s; existing session and attachment remained available.
|
||||
- Persistence: restarted API, HAProxy, PostgreSQL, Valkey, and RustFS without deleting volumes; existing data, session, and attachment remained available.
|
||||
|
||||
Reconciler track 2
|
||||
- `reconcile-scenarios.json`: dry-run found missing metadata and untracked object; apply marked missing object failed; fresh orphan and referenced attachment were preserved; second apply produced 0 actions.
|
||||
- `reconcile-unit.txt`: dry-run preserved grace-expired orphan; apply deleted it; repeated apply was idempotent.
|
||||
|
||||
All commands and measurements above were observed on the local lab environment; throughput is a single-run sample, not a production benchmark.
|
||||
@@ -0,0 +1 @@
|
||||
{"apply_elapsed_seconds": 0.0714, "apply_missing_marked_failed": true, "dry_run_elapsed_seconds": 0.0755, "dry_run_missing_detected": true, "dry_run_orphan_detected": true, "fresh_object_deferred": true, "fresh_orphan_preserved_by_grace": true, "referenced_attachment_preserved": true, "repeat_elapsed_seconds": 0.0706, "second_apply_actions": 0}
|
||||
@@ -0,0 +1,2 @@
|
||||
PASS: dry-run preserved orphan; apply deleted grace-expired orphan; repeated apply was idempotent
|
||||
elapsed_seconds_dry=0.0001 apply=0.0000 repeat=0.0000
|
||||
@@ -0,0 +1,33 @@
|
||||
global
|
||||
log stdout format raw local0
|
||||
maxconn 2048
|
||||
hard-stop-after 8s
|
||||
|
||||
defaults
|
||||
log global
|
||||
mode http
|
||||
option httplog
|
||||
timeout connect 1s
|
||||
timeout client 60s
|
||||
timeout server 60s
|
||||
timeout http-request 5s
|
||||
retries 1
|
||||
option redispatch
|
||||
option httpchk GET /health/ready
|
||||
http-check expect status 200
|
||||
|
||||
resolvers docker
|
||||
nameserver embedded 127.0.0.11:53
|
||||
resolve_retries 3
|
||||
timeout resolve 1s
|
||||
timeout retry 1s
|
||||
hold valid 2s
|
||||
hold obsolete 2s
|
||||
|
||||
frontend public_api
|
||||
bind :8080
|
||||
default_backend messenger_api
|
||||
|
||||
backend messenger_api
|
||||
balance roundrobin
|
||||
server-template api 1-16 api:8080 check inter 1s fall 2 rise 2 resolvers docker init-addr libc,none
|
||||
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"Version": "2012-10-17",
|
||||
"Statement": [{
|
||||
"Effect": "Allow",
|
||||
"Action": ["s3:ListBucket"],
|
||||
"Resource": ["arn:aws:s3:::messenger-attachments"],
|
||||
"Condition": {"StringLike": {"s3:prefix": ["attachments/*"]}}
|
||||
}, {
|
||||
"Effect": "Allow",
|
||||
"Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
|
||||
"Resource": ["arn:aws:s3:::messenger-attachments/attachments/*"]
|
||||
}]
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
rc alias set local http://rustfs:9000 "$RUSTFS_ROOT_ACCESS_KEY" "$RUSTFS_ROOT_SECRET_KEY" >/dev/null
|
||||
attempt=0
|
||||
until rc ls local/ >/dev/null 2>&1; do
|
||||
attempt=$((attempt + 1))
|
||||
if [ "$attempt" -ge 60 ]; then echo 'RustFS did not become ready' >&2; exit 1; fi
|
||||
sleep 2
|
||||
done
|
||||
rc bucket create --ignore-existing "local/$S3_BUCKET" >/dev/null
|
||||
if ! rc admin user list local/ 2>/dev/null | grep -Fq "$S3_API_ACCESS_KEY"; then
|
||||
rc admin user add local/ "$S3_API_ACCESS_KEY" "$S3_API_SECRET_KEY" >/dev/null
|
||||
fi
|
||||
sed "s/messenger-attachments/$S3_BUCKET/g" /bootstrap/policy.json > /tmp/messenger-api-policy.json
|
||||
rc admin policy create local/ messenger-api /tmp/messenger-api-policy.json >/dev/null 2>&1 || true
|
||||
rc admin policy attach local/ messenger-api --user "$S3_API_ACCESS_KEY" >/dev/null
|
||||
printf '%s\n' 'Private bucket and restricted API user are ready.'
|
||||
@@ -0,0 +1,39 @@
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username varchar(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
display_name varchar(100) NOT NULL CHECK (length(btrim(display_name)) > 0),
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title varchar(100) NOT NULL CHECK (length(btrim(title)) > 0),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
CREATE INDEX chat_members_by_user ON chat_members(user_id, chat_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
sender_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
|
||||
text varchar(4000) NOT NULL CHECK (length(btrim(text)) > 0),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE INDEX messages_history_keyset ON messages(chat_id, created_at, id);
|
||||
|
||||
-- PostgreSQL is authoritative for session durability and revocation. Valkey only
|
||||
-- keeps a short-lived lookup hint; a cache hit is still checked against this row.
|
||||
CREATE TABLE sessions (
|
||||
token_hash char(64) PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
expires_at timestamptz NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE INDEX sessions_expiry ON sessions(expires_at);
|
||||
@@ -0,0 +1,11 @@
|
||||
CREATE TABLE idempotency_keys (
|
||||
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
method varchar(8) NOT NULL CHECK (method = 'POST'),
|
||||
resource_path text NOT NULL,
|
||||
key varchar(128) NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'),
|
||||
request_hash char(64) NOT NULL,
|
||||
response_body jsonb NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
PRIMARY KEY (user_id, method, resource_path, key)
|
||||
);
|
||||
CREATE INDEX idempotency_expiry ON idempotency_keys(created_at);
|
||||
@@ -0,0 +1,30 @@
|
||||
ALTER TABLE messages DROP CONSTRAINT IF EXISTS messages_text_check;
|
||||
ALTER TABLE messages ADD CONSTRAINT messages_text_length_check CHECK (length(text) <= 4000);
|
||||
ALTER TABLE messages ADD CONSTRAINT messages_id_chat_unique UNIQUE (id, chat_id);
|
||||
|
||||
CREATE TABLE attachments (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
owner_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
|
||||
object_key text NOT NULL UNIQUE,
|
||||
filename varchar(255) NOT NULL CHECK (length(filename) BETWEEN 1 AND 255),
|
||||
content_type varchar(20) NOT NULL CHECK (content_type IN ('image/png','image/jpeg')),
|
||||
size_bytes bigint NOT NULL CHECK (size_bytes BETWEEN 1 AND 10485760),
|
||||
sha256 char(64) NOT NULL CHECK (sha256 ~ '^[0-9a-f]{64}$'),
|
||||
status varchar(16) NOT NULL CHECK (status IN ('ready','failed')),
|
||||
error_code varchar(64),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
updated_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
UNIQUE (id, chat_id)
|
||||
);
|
||||
CREATE INDEX attachments_chat_created ON attachments(chat_id, created_at);
|
||||
|
||||
CREATE TABLE message_attachments (
|
||||
message_id uuid NOT NULL,
|
||||
attachment_id uuid NOT NULL,
|
||||
chat_id uuid NOT NULL,
|
||||
PRIMARY KEY (message_id, attachment_id),
|
||||
FOREIGN KEY (message_id, chat_id) REFERENCES messages(id, chat_id) ON DELETE CASCADE,
|
||||
FOREIGN KEY (attachment_id, chat_id) REFERENCES attachments(id, chat_id) ON DELETE RESTRICT
|
||||
);
|
||||
CREATE INDEX message_attachments_by_attachment ON message_attachments(attachment_id);
|
||||
@@ -0,0 +1,11 @@
|
||||
argon2-cffi==23.1.0
|
||||
argon2-cffi-bindings==26.1.0
|
||||
cffi==2.1.1
|
||||
pycparser==3.12
|
||||
psycopg[binary,pool]==3.2.3
|
||||
psycopg-binary==3.2.3
|
||||
psycopg-pool==3.3.3
|
||||
redis==5.2.1
|
||||
typing_extensions==4.16.0
|
||||
boto3==1.35.99
|
||||
Pillow==11.0.0
|
||||
Executable
+23
@@ -0,0 +1,23 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
if [ -e .env ]; then
|
||||
echo '.env already exists; refusing to overwrite it.' >&2
|
||||
exit 2
|
||||
fi
|
||||
python3 - <<'PY'
|
||||
from pathlib import Path
|
||||
import os, secrets
|
||||
source=Path('.env.example').read_text(encoding='utf-8')
|
||||
values={
|
||||
'CHANGE-ME-postgres-long-random-secret':secrets.token_urlsafe(32),
|
||||
'CHANGE-ME-random-32-byte-secret':secrets.token_urlsafe(32),
|
||||
'CHANGE-ME-rustfs-root-long-secret':secrets.token_urlsafe(32),
|
||||
'CHANGE-ME-s3-api-long-secret':secrets.token_urlsafe(32),
|
||||
'MESSENGERADMIN':'ROOT'+secrets.token_hex(10).upper(),
|
||||
'MESSENGERAPI':'API'+secrets.token_hex(10).upper(),
|
||||
}
|
||||
for old,new in values.items(): source=source.replace(old,new)
|
||||
p=Path('.env'); p.write_text(source,encoding='utf-8'); os.chmod(p,0o600)
|
||||
PY
|
||||
printf '%s\n' 'Created .env with fresh local credentials (mode 0600).'
|
||||
Executable
+69
@@ -0,0 +1,69 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Reconcile the private S3 bucket with attachment metadata.
|
||||
|
||||
Dry-run is the default. Apply mode only removes old untracked objects and old
|
||||
unreferenced attachment records after the grace period. Missing tracked objects
|
||||
are marked failed, never silently recreated. Referenced attachments are never
|
||||
removed by this tool.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
import argparse, json, os, sys, time
|
||||
from datetime import datetime, timedelta, timezone
|
||||
import boto3
|
||||
import psycopg
|
||||
from psycopg.rows import dict_row
|
||||
from botocore.config import Config
|
||||
|
||||
|
||||
def main() -> int:
|
||||
p=argparse.ArgumentParser(description=__doc__)
|
||||
p.add_argument("--apply",action="store_true",help="apply safe repairs; default only reports")
|
||||
p.add_argument("--grace-seconds",type=int,default=86400)
|
||||
args=p.parse_args()
|
||||
if args.grace_seconds<3600:
|
||||
p.error("--grace-seconds must be at least 3600 (one hour)")
|
||||
start=time.monotonic(); cutoff=datetime.now(timezone.utc)-timedelta(seconds=args.grace_seconds)
|
||||
s3=boto3.client("s3",endpoint_url=os.getenv("S3_ENDPOINT","http://localhost:9000"),region_name=os.getenv("S3_REGION","us-east-1"),aws_access_key_id=os.environ["S3_ACCESS_KEY_ID"],aws_secret_access_key=os.environ["S3_SECRET_ACCESS_KEY"],config=Config(connect_timeout=3,read_timeout=15,retries={"max_attempts":2},s3={"addressing_style":"path"}))
|
||||
conn=psycopg.connect(os.environ["DATABASE_URL"],row_factory=dict_row)
|
||||
report={"mode":"apply" if args.apply else "dry-run","grace_seconds":args.grace_seconds,"untracked_objects":[],"missing_objects":[],"stale_unreferenced_metadata":[],"deferred_fresh_metadata":[],"actions":[],"elapsed_seconds":None}
|
||||
try:
|
||||
attachments=conn.execute("SELECT a.id,a.object_key,a.created_at,a.status,EXISTS(SELECT 1 FROM message_attachments ma WHERE ma.attachment_id=a.id) AS referenced FROM attachments a").fetchall()
|
||||
by_key={a["object_key"]:a for a in attachments}; seen={}; token=None
|
||||
while True:
|
||||
params={"Bucket":os.getenv("S3_BUCKET","messenger-attachments"),"Prefix":"attachments/"}
|
||||
if token: params["ContinuationToken"]=token
|
||||
page=s3.list_objects_v2(**params)
|
||||
for obj in page.get("Contents",[]):
|
||||
key=obj["Key"]; seen[key]=obj["LastModified"].astimezone(timezone.utc)
|
||||
if key not in by_key:
|
||||
record={"key":key,"last_modified":obj["LastModified"].astimezone(timezone.utc).isoformat(),"size_bytes":obj["Size"]}
|
||||
report["untracked_objects"].append(record)
|
||||
if args.apply and obj["LastModified"].astimezone(timezone.utc)<cutoff:
|
||||
s3.delete_object(Bucket=params["Bucket"],Key=key); report["actions"].append({"action":"delete_untracked_object","key":key})
|
||||
if not page.get("IsTruncated"): break
|
||||
token=page["NextContinuationToken"]
|
||||
for a in attachments:
|
||||
if a["object_key"] not in seen:
|
||||
report["missing_objects"].append({"attachment_id":str(a["id"]),"key":a["object_key"],"status":a["status"]})
|
||||
if args.apply and a["status"]!="failed":
|
||||
conn.execute("UPDATE attachments SET status='failed',error_code='object_missing',updated_at=now() WHERE id=%s",(a["id"],)); report["actions"].append({"action":"mark_missing_failed","attachment_id":str(a["id"])})
|
||||
object_is_old=a["object_key"] not in seen or seen[a["object_key"]]<cutoff
|
||||
if not a["referenced"] and a["created_at"].astimezone(timezone.utc)<cutoff and not object_is_old:
|
||||
report["deferred_fresh_metadata"].append({"attachment_id":str(a["id"]),"key":a["object_key"],"reason":"object_is_within_grace_period"})
|
||||
if not a["referenced"] and a["created_at"].astimezone(timezone.utc)<cutoff and object_is_old:
|
||||
report["stale_unreferenced_metadata"].append({"attachment_id":str(a["id"]),"key":a["object_key"],"status":a["status"]})
|
||||
if args.apply:
|
||||
# Recheck reference and age inside the write transaction to avoid racing a message send.
|
||||
with conn.transaction():
|
||||
row=conn.execute("SELECT status,created_at,NOT EXISTS(SELECT 1 FROM message_attachments WHERE attachment_id=%s) AS unused FROM attachments WHERE id=%s FOR UPDATE",(a["id"],a["id"])).fetchone()
|
||||
if row and row["unused"] and row["created_at"].astimezone(timezone.utc)<cutoff:
|
||||
if a["object_key"] in seen: s3.delete_object(Bucket=os.getenv("S3_BUCKET","messenger-attachments"),Key=a["object_key"])
|
||||
conn.execute("DELETE FROM attachments WHERE id=%s",(a["id"],)); report["actions"].append({"action":"delete_stale_unreferenced","attachment_id":str(a["id"])})
|
||||
if args.apply: conn.commit()
|
||||
report["elapsed_seconds"]=round(time.monotonic()-start,4)
|
||||
print(json.dumps(report,ensure_ascii=False,sort_keys=True,indent=2,default=str))
|
||||
return 0
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
if __name__=="__main__": sys.exit(main())
|
||||
Executable
+4
@@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Restart every API and stateful store while preserving all named volumes.
|
||||
docker compose --env-file .env restart api haproxy postgres valkey rustfs
|
||||
Executable
+14
@@ -0,0 +1,14 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
: "${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID is required}"
|
||||
# X-Instance-Id is the container hostname (the Docker short ID). Resolve it to
|
||||
# exactly one scaled Compose container and stop only that process.
|
||||
for id in $(docker compose --env-file .env ps -q api); do
|
||||
hostname=$(docker inspect --format '{{.Config.Hostname}}' "$id")
|
||||
if [ "$hostname" = "$TARGET_INSTANCE_ID" ]; then
|
||||
docker stop --time 3 "$id" >/dev/null
|
||||
exit 0
|
||||
fi
|
||||
done
|
||||
echo "No running api container matches TARGET_INSTANCE_ID" >&2
|
||||
exit 1
|
||||
@@ -0,0 +1,422 @@
|
||||
#!/usr/bin/env python3
|
||||
"""PostgreSQL-backed messenger API for MTUSI lab 2."""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64, binascii, hashlib, json, logging, os, re, secrets, signal, socket, tempfile, threading, time, uuid
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
from urllib.parse import parse_qs, quote, urlsplit
|
||||
|
||||
import psycopg
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import ConnectionPool, PoolTimeout
|
||||
import redis
|
||||
from argon2 import PasswordHasher, exceptions as argon_exc
|
||||
import boto3
|
||||
from botocore.config import Config
|
||||
from botocore.exceptions import BotoCoreError, ClientError
|
||||
from PIL import Image, UnidentifiedImageError
|
||||
|
||||
LOG = logging.getLogger("messenger")
|
||||
USERNAME_RE = re.compile(r"\A[a-z0-9_]{3,32}\Z")
|
||||
POOL: ConnectionPool | None = None
|
||||
CACHE: redis.Redis | None = None
|
||||
S3 = None
|
||||
PASSWORDS = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
|
||||
MAX_BODY_BYTES = 1024 * 1024
|
||||
CURSOR_SECRET = os.getenv("CURSOR_SECRET", "local-only-change-this-cursor-secret").encode("utf-8")
|
||||
INSTANCE_ID = os.getenv("API_INSTANCE_ID") or socket.gethostname() or str(uuid.uuid4())
|
||||
IDEMPOTENCY_KEY_RE = re.compile(r"\A[A-Za-z0-9._:-]{1,128}\Z")
|
||||
MAX_UPLOAD_BYTES = int(os.getenv("MAX_UPLOAD_BYTES", "10485760"))
|
||||
MAX_IMAGE_PIXELS = int(os.getenv("MAX_IMAGE_PIXELS", "40000000"))
|
||||
BUCKET = os.getenv("S3_BUCKET", "messenger-attachments")
|
||||
UPLOAD_SLOTS = threading.BoundedSemaphore(max(1,int(os.getenv("UPLOAD_CONCURRENCY", "2"))))
|
||||
|
||||
def utcnow() -> datetime: return datetime.now(timezone.utc)
|
||||
def stamp(value: datetime) -> str: return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
|
||||
def new_id() -> str: return str(uuid.uuid4())
|
||||
|
||||
class ApiError(Exception):
|
||||
def __init__(self, status, code, message): self.status, self.code, self.message = status, code, message
|
||||
|
||||
def invalid(message="Некорректный запрос"): raise ApiError(400, "invalid_request", message)
|
||||
def unavailable(): raise ApiError(503, "unavailable", "Зависимость временно недоступна")
|
||||
|
||||
def db():
|
||||
assert POOL is not None
|
||||
return POOL.connection()
|
||||
|
||||
def migrate():
|
||||
migrations = Path(__file__).parent / "migrations"
|
||||
with db() as conn:
|
||||
conn.execute("SELECT pg_advisory_xact_lock(2026102802)")
|
||||
conn.execute("CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())")
|
||||
for migration in sorted(migrations.glob("*.sql")):
|
||||
version = migration.stem
|
||||
if conn.execute("SELECT 1 FROM schema_migrations WHERE version=%s", (version,)).fetchone() is None:
|
||||
conn.execute(migration.read_text(encoding="utf-8"))
|
||||
conn.execute("INSERT INTO schema_migrations(version) VALUES (%s)", (version,))
|
||||
|
||||
def as_user(row): return {"id": str(row["id"]), "username": row["username"], "display_name": row["display_name"], "created_at": stamp(row["created_at"])}
|
||||
def as_chat(row, members): return {"id": str(row["id"]), "title": row["title"], "member_ids": [str(x) for x in members], "created_at": stamp(row["created_at"])}
|
||||
def as_message(row): return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]), "text": row["text"], "created_at": stamp(row["created_at"]), "attachment_ids": [str(x) for x in row.get("attachment_ids", [])]}
|
||||
|
||||
def message_payload(conn, row):
|
||||
ids=conn.execute("SELECT attachment_id FROM message_attachments WHERE message_id=%s ORDER BY attachment_id",(row["id"],)).fetchall()
|
||||
return as_message({**row,"attachment_ids":[x["attachment_id"] for x in ids]})
|
||||
|
||||
def require_text(value, field, maximum):
|
||||
if not isinstance(value, str) or not value.strip() or len(value) > maximum: invalid(f"Поле {field} должно содержать от 1 до {maximum} символов и не быть пустым")
|
||||
try: value.encode("utf-8")
|
||||
except UnicodeEncodeError: invalid(f"Поле {field} должно содержать корректный Unicode")
|
||||
return value
|
||||
|
||||
def strict_object(value, allowed, required):
|
||||
if not isinstance(value, dict) or set(value)-allowed or required-set(value): invalid("Тело запроса содержит неверные поля")
|
||||
return value
|
||||
|
||||
def parse_uuid(value, label="UUID"):
|
||||
try: return str(uuid.UUID(value))
|
||||
except (ValueError, TypeError, AttributeError): invalid(f"Некорректный {label}")
|
||||
|
||||
def cursor_encode(scope, row):
|
||||
obj = {"scope":scope,"created_at":stamp(row["created_at"]),"id":str(row["id"])}
|
||||
raw = json.dumps(obj,separators=(",",":"),ensure_ascii=True).encode()
|
||||
sig = hashlib.sha256(CURSOR_SECRET+raw).digest()[:12]
|
||||
return base64.urlsafe_b64encode(raw+sig).decode().rstrip("=")
|
||||
|
||||
def cursor_decode(value, scope):
|
||||
try:
|
||||
raw = base64.urlsafe_b64decode(value+"="*(-len(value)%4)); payload,sig=raw[:-12],raw[-12:]
|
||||
if not secrets.compare_digest(sig,hashlib.sha256(CURSOR_SECRET+payload).digest()[:12]): invalid("Некорректный cursor")
|
||||
obj=json.loads(payload)
|
||||
if set(obj)!={"scope","created_at","id"} or obj["scope"]!=scope: invalid("Cursor относится к другому списку")
|
||||
dt=datetime.fromisoformat(obj["created_at"].replace("Z","+00:00")); return dt,parse_uuid(obj["id"])
|
||||
except (ValueError,TypeError,KeyError,binascii.Error): invalid("Некорректный cursor")
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
protocol_version="HTTP/1.0"
|
||||
def setup(self): super().setup(); self.connection.settimeout(3)
|
||||
def log_message(self, fmt,*args): LOG.info("%s %s %s",self.command,urlsplit(self.path).path,args[1] if len(args)>1 else "")
|
||||
def do_GET(self): self.dispatch()
|
||||
def do_POST(self): self.dispatch()
|
||||
def do_DELETE(self): self.dispatch()
|
||||
|
||||
def send_json(self,status,payload,headers=None):
|
||||
body=json.dumps(payload,ensure_ascii=False,separators=(",",":")).encode()
|
||||
self.send_response(status); self.send_header("Content-Type","application/json; charset=utf-8"); self.send_header("Content-Length",str(len(body)))
|
||||
self.send_header("X-Request-Id",self.request_id); self.send_header("X-Instance-Id",INSTANCE_ID)
|
||||
for k,v in (headers or {}).items(): self.send_header(k,v)
|
||||
self.end_headers(); self.wfile.write(body)
|
||||
def empty(self,status,headers=None):
|
||||
self.send_response(status); self.send_header("Content-Length","0"); self.send_header("X-Request-Id",self.request_id); self.send_header("X-Instance-Id",INSTANCE_ID)
|
||||
for k,v in (headers or {}).items(): self.send_header(k,v)
|
||||
self.end_headers()
|
||||
def error(self,e): self.send_json(e.status,{"error":{"code":e.code,"message":e.message,"request_id":self.request_id}},getattr(e,"headers",None))
|
||||
def read_json(self):
|
||||
if self.headers.get_content_type()!="application/json": raise ApiError(415,"unsupported_media_type","Ожидается Content-Type: application/json")
|
||||
try: n=int(self.headers.get("Content-Length",""))
|
||||
except ValueError: invalid("Некорректный Content-Length")
|
||||
if n<=0: invalid("Файл должен содержать данные")
|
||||
if n>MAX_BODY_BYTES: raise ApiError(413,"payload_too_large","Тело запроса слишком велико")
|
||||
raw=self.rfile.read(n)
|
||||
if len(raw)!=n: invalid("Тело запроса передано не полностью")
|
||||
try: val=json.loads(raw.decode("utf-8"))
|
||||
except (UnicodeError,json.JSONDecodeError): invalid("Тело запроса должно быть корректным JSON UTF-8")
|
||||
if not isinstance(val,dict): invalid("Тело запроса должно быть JSON-объектом")
|
||||
return val
|
||||
def challenge(self,scheme):
|
||||
e=ApiError(401,"unauthorized","Нет действительной сессии"); e.headers={"WWW-Authenticate":scheme}; raise e
|
||||
|
||||
def authenticate(self):
|
||||
header=self.headers.get("Authorization","")
|
||||
if not header.startswith("Bearer "): self.challenge('Bearer realm="messenger"')
|
||||
token=header[7:].strip()
|
||||
if not token or len(token)>256: self.challenge('Bearer realm="messenger"')
|
||||
digest=hashlib.sha256(token.encode()).hexdigest(); cache_key="sess:"+digest
|
||||
uid=None
|
||||
if CACHE:
|
||||
try: uid=CACHE.get(cache_key)
|
||||
except redis.RedisError: pass
|
||||
with db() as conn:
|
||||
# Valkey's expiring user ID is a lookup hint. PostgreSQL validates it
|
||||
# against the live session on every request, so missed cache deletion
|
||||
# during an outage can never keep a logged-out token valid.
|
||||
row=None
|
||||
if uid:
|
||||
row=conn.execute("SELECT u.id,u.username,u.display_name,u.created_at,s.expires_at FROM sessions s JOIN users u ON u.id=s.user_id WHERE s.token_hash=%s AND s.user_id=%s AND s.expires_at>now()",(digest,uid)).fetchone()
|
||||
if not row:
|
||||
row=conn.execute("SELECT u.id,u.username,u.display_name,u.created_at,s.expires_at FROM sessions s JOIN users u ON u.id=s.user_id WHERE s.token_hash=%s AND s.expires_at>now()",(digest,)).fetchone()
|
||||
if not row: self.challenge('Bearer realm="messenger"')
|
||||
if CACHE and str(row["id"])!=uid:
|
||||
try: CACHE.setex(cache_key,max(1,int((row["expires_at"]-utcnow()).total_seconds())),str(row["id"]))
|
||||
except redis.RedisError: pass
|
||||
return as_user(row),digest
|
||||
|
||||
def dispatch(self):
|
||||
self.request_id=secrets.token_hex(16)
|
||||
try:
|
||||
split=urlsplit(self.path); path=split.path; q=parse_qs(split.query,keep_blank_values=True)
|
||||
if path in ("/health/live","/health/ready"):
|
||||
if self.command!="GET" or q: invalid("Health endpoint принимает только GET без параметров")
|
||||
if path.endswith("ready"):
|
||||
try:
|
||||
with db() as c: c.execute("SELECT 1")
|
||||
S3.list_objects_v2(Bucket=BUCKET,Prefix="attachments/",MaxKeys=1)
|
||||
except Exception: unavailable()
|
||||
self.send_json(200,{"status":"ok"}); return
|
||||
if path=="/api/v1/users" and self.command=="POST": self.register(); return
|
||||
if path=="/api/v1/auth/sessions" and self.command=="POST": self.login(); return
|
||||
if path=="/api/v1/auth/sessions/current" and self.command=="DELETE":
|
||||
actor,digest=self.authenticate()
|
||||
with db() as c: c.execute("DELETE FROM sessions WHERE token_hash=%s",(digest,))
|
||||
if CACHE:
|
||||
try: CACHE.delete("sess:"+digest)
|
||||
except redis.RedisError: pass
|
||||
self.empty(204); return
|
||||
actor,_=self.authenticate()
|
||||
if path=="/api/v1/users/me" and self.command=="GET": self.no_query(q); self.send_json(200,actor); return
|
||||
if path=="/api/v1/chats":
|
||||
if self.command=="POST": self.no_query(q); self.create_chat(actor); return
|
||||
if self.command=="GET": self.list_chats(actor,q); return
|
||||
m=re.fullmatch(r"/api/v1/chats/([^/]+)(?:/(messages|attachments))?",path)
|
||||
if m:
|
||||
cid=parse_uuid(m.group(1),"chat_id")
|
||||
if m.group(2)=="messages":
|
||||
if self.command=="POST": self.create_message(actor,cid); return
|
||||
if self.command=="GET": self.list_messages(actor,cid,q); return
|
||||
if m.group(2)=="attachments" and self.command=="POST":
|
||||
self.upload_attachment(actor,cid,q); return
|
||||
if self.command=="GET":
|
||||
self.no_query(q)
|
||||
with db() as c:
|
||||
row=c.execute("SELECT c.id,c.title,c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s",(cid,actor["id"])).fetchone()
|
||||
if not row: raise ApiError(404,"not_found","Объект не найден")
|
||||
ids=c.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id",(cid,)).fetchall()
|
||||
self.send_json(200,as_chat(row,[x["user_id"] for x in ids])); return
|
||||
m=re.fullmatch(r"/api/v1/attachments/([^/]+)(?:/(content))?",path)
|
||||
if m:
|
||||
aid=parse_uuid(m.group(1),"attachment_id")
|
||||
if m.group(2)=="content" and self.command=="GET": self.download_attachment(actor,aid,q); return
|
||||
if m.group(2) is None and self.command=="GET": self.get_attachment(actor,aid,q); return
|
||||
raise ApiError(404,"not_found","Объект не найден")
|
||||
except ApiError as e: self.error(e)
|
||||
except (psycopg.Error,PoolTimeout,redis.RedisError,BotoCoreError,ClientError) as e: LOG.warning("dependency error request_id=%s type=%s",self.request_id,type(e).__name__); self.error(ApiError(503,"unavailable","Зависимость временно недоступна"))
|
||||
except (BrokenPipeError,ConnectionResetError): pass
|
||||
except Exception: LOG.exception("request failed request_id=%s",self.request_id); self.error(ApiError(500,"internal_error","Внутренняя ошибка сервера"))
|
||||
|
||||
def no_query(self,q):
|
||||
if q: invalid("Этот endpoint не принимает query-параметры")
|
||||
def register(self):
|
||||
b=strict_object(self.read_json(),{"username","display_name","password"},{"username","display_name","password"})
|
||||
if not isinstance(b["username"],str) or not USERNAME_RE.fullmatch(b["username"]): invalid("username должен соответствовать [a-z0-9_]{3,32}")
|
||||
name=require_text(b["display_name"],"display_name",100); password=b["password"]
|
||||
if not isinstance(password,str) or not 12<=len(password)<=128: invalid("password должен содержать от 12 до 128 символов")
|
||||
uid=new_id(); hashed=PASSWORDS.hash(password)
|
||||
try:
|
||||
with db() as c: row=c.execute("INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING id,username,display_name,created_at",(uid,b["username"],name,hashed)).fetchone()
|
||||
except psycopg.errors.UniqueViolation: raise ApiError(409,"conflict","username уже занят")
|
||||
self.send_json(201,as_user(row))
|
||||
def login(self):
|
||||
if self.headers.get("Content-Length") not in (None, "0", ""): invalid("POST /auth/sessions не принимает body")
|
||||
h=self.headers.get("Authorization","")
|
||||
try:
|
||||
if not h.startswith("Basic "): raise ValueError()
|
||||
userpass=base64.b64decode(h[6:],validate=True).decode("utf-8"); username,password=userpass.split(":",1)
|
||||
except (ValueError,UnicodeError,binascii.Error): self.challenge('Basic realm="messenger", charset="UTF-8"')
|
||||
with db() as c: row=c.execute("SELECT id,username,display_name,created_at,password_hash FROM users WHERE username=%s",(username,)).fetchone()
|
||||
# Verify a fixed dummy hash for unknown users to reduce timing-based enumeration.
|
||||
try: ok=PASSWORDS.verify(row["password_hash"] if row else DUMMY_HASH,password)
|
||||
except (argon_exc.VerificationError,ValueError): ok=False
|
||||
if not row or not ok: self.challenge('Basic realm="messenger", charset="UTF-8"')
|
||||
token=secrets.token_urlsafe(32); digest=hashlib.sha256(token.encode()).hexdigest(); ttl=int(os.getenv("SESSION_TTL_SECONDS","3600")); expires=utcnow()+timedelta(seconds=ttl)
|
||||
with db() as c: c.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,%s)",(digest,row["id"],expires))
|
||||
if CACHE:
|
||||
try: CACHE.setex("sess:"+digest,ttl,str(row["id"]))
|
||||
except redis.RedisError: pass
|
||||
self.send_json(201,{"token":token,"token_type":"Bearer","expires_at":stamp(expires),"user":as_user(row)})
|
||||
|
||||
def create_chat(self,actor):
|
||||
b=strict_object(self.read_json(),{"title","member_ids"},{"title","member_ids"}); title=require_text(b["title"],"title",100); ids=b["member_ids"]
|
||||
if not isinstance(ids,list) or not 1<=len(ids)<=100: invalid("member_ids должен содержать от 1 до 100 UUID")
|
||||
ids=[parse_uuid(v,"member_id") for v in ids]
|
||||
if len(set(ids))!=len(ids): invalid("member_ids не должен содержать повторов")
|
||||
if actor["id"] not in ids: invalid("Создатель чата должен входить в member_ids")
|
||||
cid=new_id()
|
||||
try:
|
||||
with db() as c:
|
||||
known=c.execute("SELECT id FROM users WHERE id=ANY(%s)",(ids,)).fetchall()
|
||||
if len(known)!=len(ids): invalid("Все участники чата должны быть зарегистрированы")
|
||||
row=c.execute("INSERT INTO chats(id,title) VALUES (%s,%s) RETURNING id,title,created_at",(cid,title)).fetchone()
|
||||
with c.cursor() as cursor:
|
||||
cursor.executemany("INSERT INTO chat_members(chat_id,user_id) VALUES (%s,%s)",[(cid,u) for u in ids])
|
||||
except psycopg.errors.ForeignKeyViolation: invalid("Все участники чата должны быть зарегистрированы")
|
||||
self.send_json(201,as_chat(row,ids))
|
||||
def parse_page(self,q,scope):
|
||||
if set(q)-{"limit","cursor"} or any(len(v)!=1 for v in q.values()): invalid("Неверные параметры пагинации")
|
||||
raw=q.get("limit",["50"])[0]
|
||||
if not re.fullmatch(r"[0-9]{1,3}",raw): invalid("limit должен быть целым числом от 1 до 100")
|
||||
limit=int(raw)
|
||||
if not 1<=limit<=100: invalid("limit должен быть целым числом от 1 до 100")
|
||||
cur=cursor_decode(q["cursor"][0],scope) if "cursor" in q and q["cursor"][0] else None
|
||||
if "cursor" in q and not q["cursor"][0]: invalid("cursor не должен быть пустым")
|
||||
return limit,cur
|
||||
def list_chats(self,actor,q):
|
||||
limit,cur=self.parse_page(q,"chats"); params=[actor["id"]]; clause=""
|
||||
if cur: clause=" AND (c.created_at,c.id)>(%s,%s)"; params.extend(cur)
|
||||
with db() as c:
|
||||
rows=c.execute("SELECT c.id,c.title,c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s"+clause+" ORDER BY c.created_at,c.id LIMIT %s",(*params,limit+1)).fetchall()
|
||||
items=[]
|
||||
for row in rows[:limit]:
|
||||
members=c.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id",(row["id"],)).fetchall(); items.append(as_chat(row,[m["user_id"] for m in members]))
|
||||
self.send_json(200,{"items":items,"next_cursor":cursor_encode("chats",rows[limit-1]) if len(rows)>limit else None})
|
||||
def upload_attachment(self,actor,cid,q):
|
||||
if set(q)!={"filename"} or len(q["filename"])!=1: invalid("Требуется один query-параметр filename")
|
||||
filename=q["filename"][0]
|
||||
if not isinstance(filename,str) or not 1<=len(filename)<=255 or any(ord(ch)<32 or ord(ch)==127 for ch in filename) or "/" in filename or "\\" in filename or "\x00" in filename:
|
||||
invalid("filename должен быть безопасным отображаемым именем")
|
||||
if self.headers.get_content_type() not in ("image/png","image/jpeg"):
|
||||
raise ApiError(415,"unsupported_media_type","Поддерживаются только PNG и JPEG")
|
||||
try: n=int(self.headers.get("Content-Length",""))
|
||||
except ValueError: invalid("Некорректный Content-Length")
|
||||
if n<0: invalid("Некорректный Content-Length")
|
||||
if n>MAX_UPLOAD_BYTES: raise ApiError(413,"payload_too_large","Файл превышает 10 MiB")
|
||||
with db() as c:
|
||||
if not c.execute("SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s",(cid,actor["id"])).fetchone(): raise ApiError(404,"not_found","Объект не найден")
|
||||
if not UPLOAD_SLOTS.acquire(timeout=10): raise ApiError(503,"unavailable","Слишком много одновременных загрузок")
|
||||
content_type=self.headers.get_content_type(); expected={"image/png":"PNG","image/jpeg":"JPEG"}[content_type]
|
||||
try:
|
||||
digest_state=hashlib.sha256()
|
||||
with tempfile.SpooledTemporaryFile(max_size=1024*1024,mode="w+b") as data:
|
||||
remaining=n
|
||||
while remaining:
|
||||
chunk=self.rfile.read(min(64*1024,remaining))
|
||||
if not chunk: invalid("Файл передан не полностью")
|
||||
data.write(chunk); digest_state.update(chunk); remaining-=len(chunk)
|
||||
digest=digest_state.hexdigest()
|
||||
try:
|
||||
data.seek(0)
|
||||
with Image.open(data) as image:
|
||||
if image.format!=expected: raise ApiError(415,"unsupported_media_type","Content-Type не соответствует изображению")
|
||||
width,height=image.size
|
||||
if width*height>MAX_IMAGE_PIXELS: raise ApiError(413,"payload_too_large","Изображение превышает 40 млн пикселей")
|
||||
image.verify()
|
||||
data.seek(0)
|
||||
with Image.open(data) as image: image.load()
|
||||
except ApiError: raise
|
||||
except (UnidentifiedImageError,OSError,ValueError,Image.DecompressionBombError):
|
||||
raise ApiError(415,"unsupported_media_type","Изображение повреждено или не поддерживается")
|
||||
aid=new_id(); key=f"attachments/{aid}"
|
||||
data.seek(0)
|
||||
S3.put_object(Bucket=BUCKET,Key=key,Body=data,ContentType=content_type,Metadata={"sha256":digest,"attachment-id":aid})
|
||||
try:
|
||||
with db() as c:
|
||||
row=c.execute("INSERT INTO attachments(id,chat_id,owner_id,object_key,filename,content_type,size_bytes,sha256,status) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,'ready') RETURNING *",(aid,cid,actor["id"],key,filename,content_type,n,digest)).fetchone()
|
||||
except Exception:
|
||||
try: S3.delete_object(Bucket=BUCKET,Key=key)
|
||||
except Exception: LOG.exception("S3 compensation failed for attachment %s",aid)
|
||||
raise
|
||||
except (psycopg.Error,PoolTimeout): raise
|
||||
finally: UPLOAD_SLOTS.release()
|
||||
self.send_json(201,self.attachment_json(row))
|
||||
def attachment_json(self,row):
|
||||
if row["status"]!="ready": raise ApiError(409,"conflict","Вложение недоступно")
|
||||
return {"id":str(row["id"]),"chat_id":str(row["chat_id"]),"owner_id":str(row["owner_id"]),"filename":row["filename"],"content_type":row["content_type"],"size_bytes":row["size_bytes"],"sha256":row["sha256"],"status":"ready","variants":[],"error_code":None,"created_at":stamp(row["created_at"]),"updated_at":stamp(row["updated_at"])}
|
||||
def authorized_attachment(self,actor,aid):
|
||||
with db() as c:
|
||||
row=c.execute("SELECT a.* FROM attachments a JOIN chat_members m ON m.chat_id=a.chat_id WHERE a.id=%s AND m.user_id=%s",(aid,actor["id"])).fetchone()
|
||||
if not row: raise ApiError(404,"not_found","Объект не найден")
|
||||
return row
|
||||
def get_attachment(self,actor,aid,q):
|
||||
self.no_query(q); row=self.authorized_attachment(actor,aid); self.send_json(200,self.attachment_json(row))
|
||||
def download_attachment(self,actor,aid,q):
|
||||
if set(q)-{"variant"} or len(q.get("variant",["original"]))!=1: invalid("Недопустимые параметры")
|
||||
if q.get("variant",["original"])[0]!="original": raise ApiError(404,"not_found","Вариант не найден")
|
||||
row=self.authorized_attachment(actor,aid)
|
||||
if row["status"]!="ready": raise ApiError(409,"conflict","Вложение недоступно")
|
||||
obj=S3.get_object(Bucket=BUCKET,Key=row["object_key"]); data=obj["Body"].read(MAX_UPLOAD_BYTES+1)
|
||||
if len(data)>MAX_UPLOAD_BYTES: unavailable()
|
||||
headers={"Content-Type":row["content_type"],"Content-Length":str(len(data)),"Content-Disposition":"attachment; filename*=UTF-8''"+quote(row["filename"].encode("utf-8"),safe=""),'X-Content-SHA256':row["sha256"]}
|
||||
self.send_response(200)
|
||||
for k,v in headers.items(): self.send_header(k,v)
|
||||
self.send_header("X-Request-Id",self.request_id); self.send_header("X-Instance-Id",INSTANCE_ID); self.end_headers(); self.wfile.write(data)
|
||||
def create_message(self,actor,cid):
|
||||
self.no_query(parse_qs(urlsplit(self.path).query,keep_blank_values=True))
|
||||
key=self.headers.get("Idempotency-Key", "")
|
||||
if not IDEMPOTENCY_KEY_RE.fullmatch(key): invalid("Idempotency-Key обязателен и должен соответствовать [A-Za-z0-9._:-]{1,128}")
|
||||
with db() as c:
|
||||
if not c.execute("SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s",(cid,actor["id"])).fetchone(): raise ApiError(404,"not_found","Объект не найден")
|
||||
b=strict_object(self.read_json(),{"text","attachment_ids"},{"text"}); text=b["text"]
|
||||
attachment_ids=b.get("attachment_ids", [])
|
||||
if not isinstance(text,str) or len(text)>4000: invalid("text должен содержать не более 4000 символов")
|
||||
if not isinstance(attachment_ids,list) or len(attachment_ids)>10: invalid("attachment_ids должен содержать от 0 до 10 ID")
|
||||
attachment_ids=[parse_uuid(v,"attachment_id") for v in attachment_ids]
|
||||
if len(set(attachment_ids))!=len(attachment_ids): invalid("attachment_ids не должен содержать повторов")
|
||||
if not text.strip() and not attachment_ids: invalid("Сообщение должно содержать текст или вложение")
|
||||
if text.strip(): require_text(text,"text",4000)
|
||||
attachment_ids=sorted(attachment_ids)
|
||||
canonical=json.dumps({"text":text,"attachment_ids":attachment_ids},ensure_ascii=False,sort_keys=True,separators=(",",":"))
|
||||
request_hash=hashlib.sha256(canonical.encode("utf-8")).hexdigest()
|
||||
resource_path=f"/api/v1/chats/{cid}/messages"
|
||||
scope=f"{actor['id']}\nPOST\n{resource_path}\n{key}"
|
||||
try:
|
||||
with db() as c:
|
||||
# One transaction-scoped lock serializes equal keys across API replicas.
|
||||
c.execute("SELECT pg_advisory_xact_lock(hashtextextended(%s,0))",(scope,))
|
||||
old=c.execute("SELECT request_hash,response_body FROM idempotency_keys WHERE user_id=%s AND method='POST' AND resource_path=%s AND key=%s AND created_at>now()-interval '24 hours'",(actor["id"],resource_path,key)).fetchone()
|
||||
if old:
|
||||
if old["request_hash"]!=request_hash: raise ApiError(409,"conflict","Idempotency-Key уже использован с другим содержимым")
|
||||
payload=old["response_body"]
|
||||
else:
|
||||
c.execute("DELETE FROM idempotency_keys WHERE user_id=%s AND method='POST' AND resource_path=%s AND key=%s",(actor["id"],resource_path,key))
|
||||
if attachment_ids:
|
||||
allowed=c.execute("SELECT id,status FROM attachments WHERE id=ANY(%s) AND chat_id=%s",(attachment_ids,cid)).fetchall()
|
||||
if len(allowed)!=len(attachment_ids): raise ApiError(404,"not_found","Вложение не найдено")
|
||||
if any(a["status"]!="ready" for a in allowed): raise ApiError(409,"conflict","Вложение недоступно")
|
||||
row=c.execute("INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING id,chat_id,sender_id,text,created_at",(new_id(),cid,actor["id"],text)).fetchone()
|
||||
if attachment_ids:
|
||||
with c.cursor() as cur: cur.executemany("INSERT INTO message_attachments(message_id,attachment_id,chat_id) VALUES (%s,%s,%s)",[(row["id"],aid,cid) for aid in attachment_ids])
|
||||
payload=message_payload(c,row)
|
||||
c.execute("INSERT INTO idempotency_keys(user_id,method,resource_path,key,request_hash,response_body) VALUES (%s,'POST',%s,%s,%s,%s::jsonb)",(actor["id"],resource_path,key,request_hash,json.dumps(payload,ensure_ascii=False,separators=(",",":"))))
|
||||
except psycopg.errors.ForeignKeyViolation: raise ApiError(404,"not_found","Объект не найден")
|
||||
self.send_json(201,payload)
|
||||
def list_messages(self,actor,cid,q):
|
||||
with db() as c:
|
||||
if not c.execute("SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s",(cid,actor["id"])).fetchone(): raise ApiError(404,"not_found","Объект не найден")
|
||||
limit,cur=self.parse_page(q,"messages:"+cid); params=[cid]; clause=""
|
||||
if cur: clause=" AND (created_at,id)>(%s,%s)"; params.extend(cur)
|
||||
with db() as c: rows=c.execute("SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=%s"+clause+" ORDER BY created_at,id LIMIT %s",(*params,limit+1)).fetchall()
|
||||
with db() as c: items=[message_payload(c,r) for r in rows[:limit]]
|
||||
self.send_json(200,{"items":items,"next_cursor":cursor_encode("messages:"+cid,rows[limit-1]) if len(rows)>limit else None})
|
||||
|
||||
class Server(ThreadingHTTPServer):
|
||||
daemon_threads=True; allow_reuse_address=True
|
||||
|
||||
def main():
|
||||
global POOL,CACHE,DUMMY_HASH,S3
|
||||
logging.basicConfig(level=os.getenv("LOG_LEVEL","INFO").upper(),format="%(asctime)s %(levelname)s %(message)s")
|
||||
pool_max=int(os.getenv("DB_POOL_MAX","10"))
|
||||
if not 1<=pool_max<=50: raise SystemExit("DB_POOL_MAX must be between 1 and 50")
|
||||
POOL=ConnectionPool(os.getenv("DATABASE_URL","postgresql://messenger:messenger@postgres:5432/messenger"),min_size=int(os.getenv("DB_POOL_MIN","1")),max_size=pool_max,timeout=3,kwargs={"row_factory":dict_row},open=True)
|
||||
CACHE=redis.Redis.from_url(os.getenv("CACHE_URL","redis://valkey:6379/0"),socket_connect_timeout=0.5,socket_timeout=0.5,decode_responses=True)
|
||||
S3=boto3.client("s3",endpoint_url=os.getenv("S3_ENDPOINT","http://s3:9000"),region_name=os.getenv("S3_REGION","us-east-1"),aws_access_key_id=os.getenv("S3_ACCESS_KEY_ID","messenger-api"),aws_secret_access_key=os.getenv("S3_SECRET_ACCESS_KEY","local-only-change-this-secret"),config=Config(connect_timeout=2,read_timeout=10,retries={"max_attempts":1},s3={"addressing_style":"path"}))
|
||||
DUMMY_HASH=PASSWORDS.hash("dummy-password-do-not-use-123")
|
||||
deadline=time.monotonic()+60
|
||||
while True:
|
||||
try: migrate(); break
|
||||
except (psycopg.Error, PoolTimeout):
|
||||
if time.monotonic()>deadline: raise
|
||||
LOG.info("waiting for PostgreSQL"); time.sleep(1)
|
||||
if os.getenv("RUN_MIGRATIONS_ONLY") == "1":
|
||||
POOL.close()
|
||||
return
|
||||
try: CACHE.ping()
|
||||
except redis.RedisError: LOG.warning("Valkey unavailable; session validation will use PostgreSQL")
|
||||
host=os.getenv("APP_HOST","0.0.0.0"); port=int(os.getenv("APP_PORT","8080")); server=Server((host,port),Handler)
|
||||
def stop(signum,_frame): LOG.info("received signal %s; stopping",signum); threading.Thread(target=server.shutdown,daemon=True).start()
|
||||
signal.signal(signal.SIGTERM,stop); signal.signal(signal.SIGINT,stop)
|
||||
try: LOG.info("server listening on %s:%s",host,port); server.serve_forever(poll_interval=.2)
|
||||
finally: server.server_close(); POOL.close(); LOG.info("server stopped")
|
||||
|
||||
if __name__=="__main__": main()
|
||||
+32
-31
@@ -1,57 +1,58 @@
|
||||
# Публичные проверки
|
||||
# Локальные проверки лабораторной 4
|
||||
|
||||
Python **3.9+**, стандартная библиотека. Сервер уже должен быть запущен; проверки не создают готовое приложение и сами не управляют Docker. `make check` можно выполнить на исходном skeleton, `make test` — только после реализации API. Полная OpenAPI-валидация отдельно: `make validate` после установки `requirements-dev.txt` в venv.
|
||||
Запускать после `docker compose --env-file .env up -d --build --scale api=2` и готовности `/health/ready`:
|
||||
|
||||
```sh
|
||||
make check
|
||||
make test BASE_URL=http://localhost:8080
|
||||
# без make:
|
||||
python3 tests/smoke.py --base-url http://localhost:8080
|
||||
make test BASE_URL=http://127.0.0.1:8080
|
||||
python3 tests/attachments_security.py --base-url http://127.0.0.1:8080
|
||||
python3 tests/upload_burst.py --base-url http://127.0.0.1:8080
|
||||
```
|
||||
|
||||
`smoke.py` выполняет **один сквозной сценарий**, автоматически выбирая профиль из `lab.json`: health → три пользователя → вход с lab2 → чат → сообщения → пагинация → ошибки доступа → идемпотентность с lab3 → файл с lab4 → thumbnail с lab5 → logout. Он проверяет JSON по используемому подмножеству схемы, коды/headers, Unicode, SHA-256 оригинала и фактические JPEG-размеры thumbnail. Это публичный минимум, не полный fuzz/security/load suite.
|
||||
`smoke.py` — публичный контрактный сценарий. `attachments_security.py` отдельно проверяет 413 (слишком большой файл), 415 (повреждение и MIME spoofing), 400 (опасное имя), 404 (чужой чат/пользователь). `upload_burst.py` генерирует одинаковое проверяемое PNG тело и делает 10 запросов одновременно; запишите API `memory.peak` из cgroup до/после прогона. Не запускайте параллельно другие тестовые процессы в этом стенде.
|
||||
|
||||
Каждый запуск создаёт уникальных синтетических пользователей, чат и сообщения. Данные автоматически не удаляются: в API курса нет delete. Для чистого повтора используйте отдельный тестовый стенд/volume и осознанный сброс своего окружения. Session tokens хранятся только в памяти процесса и не печатаются/не сохраняются.
|
||||
|
||||
## Проверка сохранности, lab2+
|
||||
|
||||
Скопируйте `scripts/restart.example.sh` в `scripts/restart.sh`, реализуйте перезапуск **API и всех используемых хранилищ** с сохранением volumes и задайте executable bit. Скрипт может опираться на ваш compose.yaml или stack.yaml. Он не должен удалять volumes, повторно seed-ить БД или менять тестовые данные.
|
||||
Сверка хранилищ:
|
||||
|
||||
```sh
|
||||
chmod +x scripts/restart.sh
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
# Только отчёт; не изменяет S3 или PostgreSQL.
|
||||
docker compose --env-file .env exec -T api python scripts/reconcile.py --grace-seconds 3600
|
||||
# Применение безопасных исправлений, только после проверки dry-run:
|
||||
docker compose --env-file .env exec -T api python scripts/reconcile.py --apply --grace-seconds 3600
|
||||
```
|
||||
|
||||
Тест создаёт данные и сессию, запускает указанный файл без shell interpolation, ожидает готовности и проверяет те же данные **с прежним токеном**. В lab4+ также проверяется исходный файл. Hook может работать до 90 секунд, готовность затем ожидается до 90 секунд. TTL сессии для этого теста — минимум 300 секунд. Успех не доказывает, что hook действительно перезапустил БД: приложите команды/состояния контейнеров до и после.
|
||||
В каждом контейнерном запуске reconciler нужны переменные `DATABASE_URL`, `S3_ENDPOINT`, `S3_REGION`, `S3_BUCKET`, `S3_ACCESS_KEY_ID`, `S3_SECRET_ACCESS_KEY`. Текущий Dockerfile копирует только приложение; для запуска файла из хоста используйте `docker compose exec` после добавления `scripts/reconcile.py` в образ либо запустите `.venv/bin/python scripts/reconcile.py` с локальными переменными и сетевым адресом `localhost:9000`.
|
||||
|
||||
## Проверка отказа, lab3+
|
||||
|
||||
Реализуйте `scripts/stop-one.sh` на основе примера. `TARGET_INSTANCE_ID` в окружении содержит alias обслужившей тест API-реплики: сопоставьте его своему контейнеру/Swarm task и остановите именно его. Скрипт должен быстро вернуть 0 и **оставить эту реплику остановленной**; восстановление выполняйте отдельно. Swarm может создать новую task с другим ID — это допустимо.
|
||||
`resilience.py` имеет отдельные hooks:
|
||||
|
||||
```sh
|
||||
chmod +x scripts/stop-one.sh
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://127.0.0.1:8080
|
||||
```
|
||||
|
||||
Перед отказом тест наблюдает ≥2 API-реплики; 15 секунд отправляет сообщения параллельно выполнению hook, повторяет неопределённый POST с тем же ключом, проверяет восстановление записи за ≤10 секунд, отсутствие остановленной реплики в последних ответах, сохранность подтверждённых сообщений и отсутствие дублей. Ошибки переходного периода учитываются. Затем восстановите реплику и повторите для другой. Скрипт — проверка одного отказа API, не гарантия HA БД/LB/host. Вывод hook скрыт, чтобы не утекли секреты; отлаживайте его отдельно с безопасным выводом.
|
||||
Failover оставляет одну реплику остановленной; восстановите масштаб командой `docker compose --env-file .env up -d --scale api=2`. Для полного перезапуска тест сам сохраняет volumes; никогда не добавляйте `down -v`.
|
||||
|
||||
## Нагрузка
|
||||
Для фактического fault injection трека 5 после публичного smoke запустите внутри API-контейнера:
|
||||
|
||||
```sh
|
||||
python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load.json
|
||||
docker compose --env-file .env exec -T api python tests/reconcile_scenarios.py
|
||||
```
|
||||
|
||||
Это простой **closed-loop** генератор POST сообщений; он ограничен производительностью клиента и страдает coordinated omission. Он выдаёт successful RPS, ошибки и p50/p95/p99 **только успешных запросов**. Во время нагрузки нет прозрачных retry; timeout мог скрыть совершённую запись, поэтому это throughput HTTP-подтверждений, не точный счётчик COMMIT. Изменение размера истории входит в профиль. Для серьёзного исследования используйте k6/Locust/wrk либо свой обоснованный генератор, а не выводите максимальную пропускную способность из одного запуска этого скрипта. Для нагрузки pipeline изображений нужен отдельный сценарий студента.
|
||||
|
||||
## HTTPS, lab7
|
||||
Сценарий временно создаёт только синтетические строки и два объекта, проверяет dry-run, apply, повторный apply, защищает свежий объект grace period и старое, но используемое вложение; затем удаляет созданные объекты/строки и восстанавливает исходную дату активного вложения.
|
||||
|
||||
```sh
|
||||
make test BASE_URL=https://localhost:8443 CA_FILE=/absolute/path/to/ca.crt
|
||||
make test-security BASE_URL=https://localhost:8443 CA_FILE=/absolute/path/to/ca.crt
|
||||
docker compose --env-file .env exec -T api python tests/private_bucket_check.py
|
||||
python3 tests/s3_failure.py --base-url http://127.0.0.1:8080
|
||||
```
|
||||
|
||||
Все скрипты принимают `--ca-file`/`CA_FILE` и проверяют серверный сертификат и hostname. `--insecure` отсутствует. TLS-тест сначала проверяет рабочее доверенное соединение, затем намеренно пустой trust store и именно ошибку проверки сертификата; network timeout не засчитывается как правильный отказ. **Внутреннее mTLS, identity/authorization, OpenBao policy и hardening проверяют отдельные тесты студента** по trust matrix. Клиентский сертификат внешнему учебному REST-клиенту не требуется: mTLS находится на внутренних связях.
|
||||
`private_bucket_check.py` временно создаёт объект прямым S3 API-вызовом с ограниченными API credentials, проверяет анонимные `ListBucket` и `GetObject`, затем удаляет объект в `finally`.
|
||||
|
||||
## Что ещё остаётся доказать
|
||||
Проверка компенсации между двумя хранилищами использует временный триггер только на тестовой базе и удаляет его в `finally`:
|
||||
|
||||
Smoke не доказывает persistence, число реальных контейнеров, durability брокера, outbox, отсутствие утечек/уязвимостей, полноту telemetry или выполнение уровня 4/5. Конкурентные/нагрузочные/негативные проверки своего решения добавляйте отдельно. Список защиты текущей лабы находится в README.md. Проверки рассчитаны на localhost-стенд, не на production.
|
||||
```sh
|
||||
docker compose --env-file .env run --rm --no-deps -v "$PWD:/workspace:ro" -w /workspace api python tests/compensation_check.py --base-url http://haproxy:8080
|
||||
```
|
||||
|
||||
Время ожидания grace period составляет минимум один час, поэтому сценарий удаления просроченного orphan проверяется детерминированной fake-clock/объектной выдачей. Приватная integration-сверка отдельно инжектирует свежий объект и убеждается, что он остаётся нетронутым:
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env exec -T api python tests/reconcile_unit.py
|
||||
```
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Lab 4 negative upload, chat-boundary, and attachment-id checks."""
|
||||
import uuid
|
||||
from client import Client, arguments, check, run
|
||||
|
||||
|
||||
def main():
|
||||
args=arguments('Lab 4 attachment security checks')
|
||||
c=Client(args.base_url,args.ca_file)
|
||||
alice,bob,eve,chat=c.bootstrap()
|
||||
url='/api/v1/chats/'+chat['id']+'/attachments?filename=test.png'
|
||||
fixture=(c.__class__.__module__ and __import__('pathlib').Path(__file__).parent/'fixtures'/'sample.png').read_bytes()
|
||||
c.call('POST',url,413,actor=alice,raw=b'x'*(10*1024*1024+1),headers={'Content-Type':'image/png'})
|
||||
c.call('POST',url,415,actor=alice,raw=b'broken image',headers={'Content-Type':'image/png'})
|
||||
c.call('POST',url,415,actor=alice,raw=fixture,headers={'Content-Type':'image/jpeg'})
|
||||
c.call('POST','/api/v1/chats/'+chat['id']+'/attachments?filename=../secret.png',400,actor=alice,raw=fixture,headers={'Content-Type':'image/png'})
|
||||
other=c.call('POST','/api/v1/chats',201,actor=alice,body={'title':'Другой чат','member_ids':[alice['id']]},schema='Chat')['json']
|
||||
attachment=c.call('POST','/api/v1/chats/'+other['id']+'/attachments?filename=other.png',201,actor=alice,raw=fixture,headers={'Content-Type':'image/png'},schema='Attachment')['json']
|
||||
key=uuid.uuid4().hex
|
||||
c.call('POST','/api/v1/chats/'+chat['id']+'/messages',404,actor=alice,body={'text':'cross-chat', 'attachment_ids':[attachment['id']]},headers={'Idempotency-Key':key})
|
||||
c.call('POST','/api/v1/chats/'+chat['id']+'/messages',404,actor=eve,body={'text':'foreign attachment','attachment_ids':[attachment['id']]},headers={'Idempotency-Key':uuid.uuid4().hex})
|
||||
print('PASS: oversize=413, corrupt=415, MIME spoof=415, unsafe filename=400, cross-chat/outsider attachment IDs=404')
|
||||
|
||||
if __name__=='__main__': run(main)
|
||||
@@ -0,0 +1,28 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Inject an attachment metadata error and verify the S3 PUT is compensated."""
|
||||
import os, subprocess
|
||||
from pathlib import Path
|
||||
import boto3
|
||||
from botocore.config import Config
|
||||
from client import Client, arguments, check, run
|
||||
|
||||
|
||||
def main():
|
||||
args=arguments('Lab 4 S3/DB compensation check')
|
||||
c=Client(args.base_url,args.ca_file); alice,bob,eve,chat=c.bootstrap()
|
||||
s3=boto3.client('s3',endpoint_url=os.getenv('S3_ENDPOINT','http://rustfs:9000'),region_name=os.getenv('S3_REGION','us-east-1'),aws_access_key_id=os.environ['S3_ACCESS_KEY_ID'],aws_secret_access_key=os.environ['S3_SECRET_ACCESS_KEY'],config=Config(s3={'addressing_style':'path'}))
|
||||
bucket=os.getenv('S3_BUCKET','messenger-attachments')
|
||||
before={x['Key'] for x in s3.list_objects_v2(Bucket=bucket,Prefix='attachments/').get('Contents',[])}
|
||||
sql="""CREATE OR REPLACE FUNCTION lab4_reject_attachment() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF NEW.filename='force-db-failure.png' THEN RAISE EXCEPTION 'injected lab4 metadata failure'; END IF; RETURN NEW; END $$; CREATE TRIGGER lab4_reject_attachment BEFORE INSERT ON attachments FOR EACH ROW EXECUTE FUNCTION lab4_reject_attachment();"""
|
||||
conn=subprocess.run(['python','-c','import os,psycopg; c=psycopg.connect(os.environ["DATABASE_URL"]); c.execute('+repr(sql)+'); c.commit(); c.close()'],check=True,capture_output=True,text=True)
|
||||
try:
|
||||
payload=(Path(__file__).parent/'fixtures'/'sample.png').read_bytes()
|
||||
result=c.call('POST','/api/v1/chats/'+chat['id']+'/attachments?filename=force-db-failure.png',503,actor=alice,raw=payload,headers={'Content-Type':'image/png'})
|
||||
after={x['Key'] for x in s3.list_objects_v2(Bucket=bucket,Prefix='attachments/').get('Contents',[])}
|
||||
check(after==before,'S3 object remained after injected PostgreSQL insert failure')
|
||||
print('PASS: injected metadata failure returned 503 and compensating S3 delete left no orphan object')
|
||||
finally:
|
||||
drop="DROP TRIGGER IF EXISTS lab4_reject_attachment ON attachments; DROP FUNCTION IF EXISTS lab4_reject_attachment();"
|
||||
subprocess.run(['python','-c','import os,psycopg; c=psycopg.connect(os.environ["DATABASE_URL"]); c.execute('+repr(drop)+'); c.commit(); c.close()'],check=True,capture_output=True,text=True)
|
||||
|
||||
if __name__=='__main__': run(main)
|
||||
@@ -0,0 +1,23 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Concurrent duplicate POSTs through LB; assert one stable message result."""
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
import uuid
|
||||
from client import Client, arguments, check, run
|
||||
|
||||
def main():
|
||||
args=arguments('Parallel retry test through the shared load balancer')
|
||||
base=Client(args.base_url,args.ca_file,timeout=10)
|
||||
alice,bob,eve,chat=base.bootstrap(); key='race:'+uuid.uuid4().hex
|
||||
body={'text':'Параллельная отправка'}
|
||||
def send(_):
|
||||
c=Client(args.base_url,args.ca_file,timeout=10)
|
||||
return c.call('POST',f"/api/v1/chats/{chat['id']}/messages",201,actor=alice,body=body,headers={'Idempotency-Key':key},schema='Message')
|
||||
with ThreadPoolExecutor(max_workers=16) as pool: replies=list(pool.map(send,range(32)))
|
||||
ids={r['json']['id'] for r in replies}; instances={r['headers']['X-Instance-Id'] for r in replies}
|
||||
check(len(ids)==1,'concurrent retries created more than one message')
|
||||
check(len(instances)>=2,'test did not observe requests served by two API replicas')
|
||||
history=base.call('GET',f"/api/v1/chats/{chat['id']}/messages?limit=100",actor=bob,schema='MessagePage')['json']['items']
|
||||
check(sum(m['id'] in ids for m in history)==1,'message is not visible exactly once through LB')
|
||||
print(f'PASS: 32 concurrent retries, one message, {len(instances)} API instances observed')
|
||||
|
||||
if __name__=='__main__': run(main)
|
||||
@@ -0,0 +1,39 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Verify anonymous S3 listing and direct object download are denied."""
|
||||
import os
|
||||
import uuid
|
||||
|
||||
import boto3
|
||||
from botocore import UNSIGNED
|
||||
from botocore.config import Config
|
||||
from botocore.exceptions import ClientError
|
||||
|
||||
endpoint=os.getenv('S3_ENDPOINT','http://rustfs:9000')
|
||||
bucket=os.getenv('S3_BUCKET','messenger-attachments')
|
||||
region=os.getenv('S3_REGION','us-east-1')
|
||||
cfg=Config(s3={'addressing_style':'path'})
|
||||
signed=boto3.client('s3',endpoint_url=endpoint,region_name=region,
|
||||
aws_access_key_id=os.environ['S3_ACCESS_KEY_ID'],
|
||||
aws_secret_access_key=os.environ['S3_SECRET_ACCESS_KEY'],config=cfg)
|
||||
anonymous=boto3.client('s3',endpoint_url=endpoint,region_name=region,
|
||||
config=Config(signature_version=UNSIGNED,s3={'addressing_style':'path'}))
|
||||
key='attachments/private-check/'+uuid.uuid4().hex
|
||||
|
||||
def denied(operation, **kwargs):
|
||||
try:
|
||||
response=operation(**kwargs)
|
||||
body=response.get('Body')
|
||||
if body: body.close()
|
||||
except ClientError as exc:
|
||||
status=exc.response.get('ResponseMetadata',{}).get('HTTPStatusCode')
|
||||
if status in (401,403): return status
|
||||
raise
|
||||
raise AssertionError('anonymous S3 request unexpectedly succeeded')
|
||||
|
||||
try:
|
||||
signed.put_object(Bucket=bucket,Key=key,Body=b'private-bucket-check')
|
||||
list_status=denied(anonymous.list_objects_v2,Bucket=bucket,Prefix='attachments/',MaxKeys=1)
|
||||
get_status=denied(anonymous.get_object,Bucket=bucket,Key=key)
|
||||
print('PASS: anonymous ListBucket denied with HTTP %d; direct GetObject denied with HTTP %d' % (list_status,get_status))
|
||||
finally:
|
||||
signed.delete_object(Bucket=bucket,Key=key)
|
||||
@@ -0,0 +1,50 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Inject harmless fresh/missing reconciliation cases into the local stack."""
|
||||
import json, os, subprocess, sys, uuid
|
||||
from datetime import datetime, timedelta, timezone
|
||||
import boto3, psycopg
|
||||
from botocore.config import Config
|
||||
from psycopg.rows import dict_row
|
||||
|
||||
|
||||
def main():
|
||||
bucket=os.getenv('S3_BUCKET','messenger-attachments')
|
||||
s3=boto3.client('s3',endpoint_url=os.getenv('S3_ENDPOINT','http://localhost:9000'),region_name=os.getenv('S3_REGION','us-east-1'),aws_access_key_id=os.environ['S3_ACCESS_KEY_ID'],aws_secret_access_key=os.environ['S3_SECRET_ACCESS_KEY'],config=Config(s3={'addressing_style':'path'}))
|
||||
conn=psycopg.connect(os.environ['DATABASE_URL'],row_factory=dict_row)
|
||||
missing_id, fresh_id, object_key=str(uuid.uuid4()),str(uuid.uuid4()),'attachments/reconcile-test-'+uuid.uuid4().hex
|
||||
now=datetime.now(timezone.utc); stale_key='attachments/'+fresh_id
|
||||
try:
|
||||
base=conn.execute("SELECT a.chat_id,a.owner_id FROM attachments a WHERE a.status='ready' LIMIT 1").fetchone()
|
||||
if not base: raise RuntimeError('run smoke once first so the synthetic test owner/chat exist')
|
||||
referenced=conn.execute("SELECT a.id,a.created_at,a.object_key FROM attachments a WHERE a.status='ready' AND EXISTS(SELECT 1 FROM message_attachments ma WHERE ma.attachment_id=a.id) LIMIT 1").fetchone()
|
||||
if not referenced: raise RuntimeError('run smoke once first so a referenced attachment exists')
|
||||
conn.execute("INSERT INTO attachments(id,chat_id,owner_id,object_key,filename,content_type,size_bytes,sha256,status,created_at) VALUES (%s,%s,%s,%s,'missing.png','image/png',12,%s,'ready',%s)",(missing_id,base['chat_id'],base['owner_id'],'attachments/'+missing_id,'0'*64,now))
|
||||
conn.execute("INSERT INTO attachments(id,chat_id,owner_id,object_key,filename,content_type,size_bytes,sha256,status,created_at) VALUES (%s,%s,%s,%s,'fresh-object.png','image/png',15,%s,'ready',%s)",(fresh_id,base['chat_id'],base['owner_id'],stale_key,'1'*64,now-timedelta(days=2)))
|
||||
conn.execute("UPDATE attachments SET created_at=%s WHERE id=%s",(now-timedelta(days=2),referenced['id']))
|
||||
conn.commit()
|
||||
s3.put_object(Bucket=bucket,Key=stale_key,Body=b'reconcile-fresh-object',ContentType='image/png')
|
||||
s3.put_object(Bucket=bucket,Key=object_key,Body=b'reconcile-orphan',ContentType='application/octet-stream')
|
||||
dry=json.loads(subprocess.run([sys.executable,'scripts/reconcile.py','--grace-seconds','3600'],check=True,capture_output=True,text=True).stdout)
|
||||
assert any(x['attachment_id']==missing_id for x in dry['missing_objects'])
|
||||
assert any(x['key']==object_key for x in dry['untracked_objects'])
|
||||
assert any(x['attachment_id']==fresh_id for x in dry['deferred_fresh_metadata'])
|
||||
assert not dry['actions']
|
||||
applied=json.loads(subprocess.run([sys.executable,'scripts/reconcile.py','--apply','--grace-seconds','3600'],check=True,capture_output=True,text=True).stdout)
|
||||
status=conn.execute('SELECT status FROM attachments WHERE id=%s',(missing_id,)).fetchone()['status']
|
||||
assert status=='failed'
|
||||
assert conn.execute('SELECT 1 FROM attachments WHERE id=%s',(fresh_id,)).fetchone()
|
||||
assert conn.execute('SELECT 1 FROM attachments WHERE id=%s',(referenced['id'],)).fetchone()
|
||||
s3.head_object(Bucket=bucket,Key=stale_key); s3.head_object(Bucket=bucket,Key=object_key)
|
||||
again=json.loads(subprocess.run([sys.executable,'scripts/reconcile.py','--apply','--grace-seconds','3600'],check=True,capture_output=True,text=True).stdout)
|
||||
assert not again['actions'], 'second apply should be idempotent'
|
||||
print(json.dumps({'dry_run_missing_detected':True,'dry_run_orphan_detected':True,'apply_missing_marked_failed':True,'fresh_object_deferred':True,'referenced_attachment_preserved':True,'fresh_orphan_preserved_by_grace':True,'second_apply_actions':len(again['actions']),'dry_run_elapsed_seconds':dry['elapsed_seconds'],'apply_elapsed_seconds':applied['elapsed_seconds'],'repeat_elapsed_seconds':again['elapsed_seconds']},sort_keys=True))
|
||||
finally:
|
||||
conn.execute('DELETE FROM attachments WHERE id=ANY(%s)',([missing_id,fresh_id],))
|
||||
if 'referenced' in locals() and referenced: conn.execute('UPDATE attachments SET created_at=%s WHERE id=%s',(referenced['created_at'],referenced['id']))
|
||||
conn.commit()
|
||||
for key in (stale_key,object_key):
|
||||
try: s3.delete_object(Bucket=bucket,Key=key)
|
||||
except Exception: pass
|
||||
conn.close()
|
||||
|
||||
if __name__=='__main__': main()
|
||||
@@ -0,0 +1,37 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Deterministic policy check for grace-expired S3-only objects."""
|
||||
from contextlib import redirect_stdout
|
||||
from datetime import datetime, timedelta, timezone
|
||||
import importlib.util, io, os, sys
|
||||
from unittest.mock import patch
|
||||
|
||||
spec=importlib.util.spec_from_file_location('reconcile','scripts/reconcile.py')
|
||||
module=importlib.util.module_from_spec(spec); spec.loader.exec_module(module)
|
||||
|
||||
class Rows:
|
||||
def fetchall(self): return []
|
||||
class FakeConn:
|
||||
def execute(self,*args,**kwargs): return Rows()
|
||||
def commit(self): pass
|
||||
def close(self): pass
|
||||
class FakeS3:
|
||||
def __init__(self): self.keys={'attachments/old-orphan'}; self.deleted=[]
|
||||
def list_objects_v2(self,**kwargs):
|
||||
return {'Contents':[{'Key':key,'LastModified':datetime.now(timezone.utc)-timedelta(days=2),'Size':128} for key in sorted(self.keys)],'IsTruncated':False}
|
||||
def delete_object(self,**kwargs):
|
||||
self.deleted.append(kwargs['Key']); self.keys.discard(kwargs['Key'])
|
||||
|
||||
s3=FakeS3(); outputs=[]; deletes_after_each=[]
|
||||
for apply in (False,True,True):
|
||||
argv=['reconcile.py','--grace-seconds','3600']+(['--apply'] if apply else [])
|
||||
stream=io.StringIO()
|
||||
with patch.object(sys,'argv',argv),patch('boto3.client',return_value=s3),patch('psycopg.connect',return_value=FakeConn()),patch.dict(os.environ,{'DATABASE_URL':'postgresql://test','S3_ACCESS_KEY_ID':'TEST','S3_SECRET_ACCESS_KEY':'TEST'}),redirect_stdout(stream):
|
||||
code=module.main()
|
||||
if code!=0: raise AssertionError('reconciler returned non-zero')
|
||||
outputs.append(__import__('json').loads(stream.getvalue()))
|
||||
deletes_after_each.append(len(s3.deleted))
|
||||
assert outputs[0]['untracked_objects'] and not outputs[0]['actions'] and deletes_after_each[0]==0
|
||||
assert outputs[1]['actions']==[{'action':'delete_untracked_object','key':'attachments/old-orphan'}]
|
||||
assert outputs[2]['actions']==[] and deletes_after_each==[0,1,1]
|
||||
print('PASS: dry-run preserved orphan; apply deleted grace-expired orphan; repeated apply was idempotent')
|
||||
print('elapsed_seconds_dry=%.4f apply=%.4f repeat=%.4f' % (outputs[0]['elapsed_seconds'],outputs[1]['elapsed_seconds'],outputs[2]['elapsed_seconds']))
|
||||
@@ -0,0 +1,26 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Verify RustFS outage through the API process and recover the service."""
|
||||
import subprocess, time
|
||||
from client import Client, arguments, run
|
||||
|
||||
|
||||
def main():
|
||||
args=arguments('Lab 4 S3 dependency outage check')
|
||||
c=Client(args.base_url,args.ca_file); alice,bob,eve,chat=c.bootstrap()
|
||||
subprocess.run(['docker','compose','--env-file','.env','stop','rustfs'],check=True,stdout=subprocess.DEVNULL)
|
||||
try:
|
||||
probe=subprocess.run(['docker','compose','--env-file','.env','exec','-T','-e','LAB_TEST_TOKEN='+alice['token'],'-e','LAB_TEST_CHAT='+chat['id'],'api','python','tests/s3_failure_probe.py'],check=True,capture_output=True,text=True)
|
||||
print(probe.stdout.strip())
|
||||
finally:
|
||||
subprocess.run(['docker','compose','--env-file','.env','start','rustfs'],check=True,stdout=subprocess.DEVNULL)
|
||||
deadline=time.monotonic()+60
|
||||
while time.monotonic()<deadline:
|
||||
try:
|
||||
c.call('GET','/health/ready',200)
|
||||
print('PASS: readiness returned 200 after RustFS restart')
|
||||
return
|
||||
except AssertionError:
|
||||
time.sleep(1)
|
||||
raise AssertionError('health did not recover after RustFS restart')
|
||||
|
||||
if __name__=='__main__': run(main)
|
||||
@@ -0,0 +1,17 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Run inside an API container while the RustFS service is stopped."""
|
||||
import os, urllib.error, urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
base='http://127.0.0.1:8080'
|
||||
headers={'Authorization':'Bearer '+os.environ['LAB_TEST_TOKEN'],'Content-Type':'image/png'}
|
||||
def call(req):
|
||||
try:
|
||||
with urllib.request.urlopen(req,timeout=10) as response: return response.status
|
||||
except urllib.error.HTTPError as exc: return exc.code
|
||||
ready=call(urllib.request.Request(base+'/health/ready'))
|
||||
image=(Path('/app/tests/fixtures/sample.png')).read_bytes()
|
||||
req=urllib.request.Request(base+'/api/v1/chats/'+os.environ['LAB_TEST_CHAT']+'/attachments?filename=outage.png',data=image,headers=headers,method='POST')
|
||||
upload=call(req)
|
||||
if (ready,upload)!=(503,503): raise SystemExit('expected readiness/upload HTTP 503; got %d/%d'%(ready,upload))
|
||||
print('PASS: RustFS outage gives API readiness 503 and upload 503')
|
||||
@@ -0,0 +1,33 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Send ten concurrent near-maximum-safe PNG uploads and summarize traffic/time."""
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
import hashlib, random, struct, time, zlib
|
||||
from client import Client, arguments, check, run
|
||||
|
||||
|
||||
def png_noise(width=1600,height=1600):
|
||||
# RGB rows, filter type 0. Deterministic PRNG-free byte pattern keeps this
|
||||
# fixture reproducible and incompressible enough to exercise the 1 MiB spool.
|
||||
rng=random.Random(20261106)
|
||||
raw=b''.join(b'\0'+rng.randbytes(width*3) for _ in range(height))
|
||||
def chunk(tag,data): return struct.pack('!I',len(data))+tag+data+struct.pack('!I',zlib.crc32(tag+data)&0xffffffff)
|
||||
data=b'\x89PNG\r\n\x1a\n'+chunk(b'IHDR',struct.pack('!2I5B',width,height,8,2,0,0,0))+chunk(b'IDAT',zlib.compress(raw,1))+chunk(b'IEND',b'')
|
||||
check(len(data)<=10*1024*1024,'generated PNG exceeds upload limit')
|
||||
return data
|
||||
|
||||
|
||||
def main():
|
||||
args=arguments('Lab 4 concurrent upload memory/throughput sample')
|
||||
c=Client(args.base_url,args.ca_file,timeout=30)
|
||||
alice,bob,eve,chat=c.bootstrap(); data=png_noise(); sha=hashlib.sha256(data).hexdigest()
|
||||
def upload(i):
|
||||
return c.call('POST','/api/v1/chats/'+chat['id']+'/attachments?filename=burst-'+str(i)+'.png',201,actor=alice,raw=data,headers={'Content-Type':'image/png'},schema='Attachment')['json']
|
||||
start=time.monotonic(); uploaded=[]
|
||||
with ThreadPoolExecutor(max_workers=10) as pool:
|
||||
futures=[pool.submit(upload,i) for i in range(10)]
|
||||
for future in as_completed(futures): uploaded.append(future.result())
|
||||
elapsed=time.monotonic()-start
|
||||
check(len(uploaded)==10 and all(x['sha256']==sha and x['size_bytes']==len(data) for x in uploaded),'upload result/checksum mismatch')
|
||||
print('uploads=10 concurrency=10 size_bytes=%d total_bytes=%d sha256=%s elapsed_seconds=%.3f throughput_mib_s=%.2f' % (len(data),len(data)*10,sha,elapsed,len(data)*10/1048576/elapsed))
|
||||
|
||||
if __name__=='__main__': run(main)
|
||||
Reference in New Issue
Block a user