ЛР 4 — БВТ2301 — Койчакаев — на 5 #141

Open
koichakaev wants to merge 1 commits from koichakaev/mtusi2026lab4:solution/BVT2301-Koichakaev into main
30 changed files with 1250 additions and 80 deletions
+15 -16
View File
@@ -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
+14 -14
View File
@@ -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
View File
@@ -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"]
+60 -19
View File
@@ -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
View File
@@ -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:
+30
View File
@@ -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.
+1
View File
@@ -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}
+2
View File
@@ -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
+33
View File
@@ -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
+13
View File
@@ -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/*"]
}]
}
+17
View File
@@ -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.'
+39
View File
@@ -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);
+11
View File
@@ -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);
+30
View File
@@ -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);
+11
View File
@@ -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
+23
View File
@@ -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).'
+69
View File
@@ -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())
+4
View File
@@ -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
+14
View File
@@ -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
+422
View File
@@ -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
View File
@@ -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
```
+24
View File
@@ -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)
+28
View File
@@ -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)
+23
View File
@@ -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)
+39
View File
@@ -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)
+50
View File
@@ -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()
+37
View File
@@ -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']))
+26
View File
@@ -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)
+17
View File
@@ -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')
+33
View File
@@ -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)