diff --git a/.env.example b/.env.example index d99d26a2..1c0776bc 100644 --- a/.env.example +++ b/.env.example @@ -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 diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 1bec5472..87fb4488 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,18 +1,18 @@ ## Лабораторная 4 -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO +Автор / группа: Койчакаев Багавдин / БВТ2301 +Целевая оценка (3/4/5): 5 +Трек 5, если заявлен: трек 2 — сверка PostgreSQL/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 содержит инструкцию именно моего решения. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..1ca1694f --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..348b5766 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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/`), а имя файла хранится отдельно и не попадает в ключ. + +Загрузка ограничена 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 измерен один раз и не является универсальным сравнением. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..4f5db922 --- /dev/null +++ b/compose.yaml @@ -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: diff --git a/evidence/lab4-checks.txt b/evidence/lab4-checks.txt new file mode 100644 index 00000000..ad34e1dc --- /dev/null +++ b/evidence/lab4-checks.txt @@ -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. diff --git a/evidence/reconcile-scenarios.json b/evidence/reconcile-scenarios.json new file mode 100644 index 00000000..7883419c --- /dev/null +++ b/evidence/reconcile-scenarios.json @@ -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} diff --git a/evidence/reconcile-unit.txt b/evidence/reconcile-unit.txt new file mode 100644 index 00000000..e98400d8 --- /dev/null +++ b/evidence/reconcile-unit.txt @@ -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 diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 00000000..9fa3c16b --- /dev/null +++ b/infra/haproxy.cfg @@ -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 diff --git a/infra/rustfs-api-policy.json b/infra/rustfs-api-policy.json new file mode 100644 index 00000000..0a545dd4 --- /dev/null +++ b/infra/rustfs-api-policy.json @@ -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/*"] + }] +} diff --git a/infra/rustfs-bootstrap.sh b/infra/rustfs-bootstrap.sh new file mode 100644 index 00000000..391ae9fc --- /dev/null +++ b/infra/rustfs-bootstrap.sh @@ -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.' diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..eccf09ef --- /dev/null +++ b/migrations/001_initial.sql @@ -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); diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..6e9877d5 --- /dev/null +++ b/migrations/002_idempotency.sql @@ -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); diff --git a/migrations/003_attachments.sql b/migrations/003_attachments.sql new file mode 100644 index 00000000..f8e56f80 --- /dev/null +++ b/migrations/003_attachments.sql @@ -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); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..c270b0b0 --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/scripts/init-env.sh b/scripts/init-env.sh new file mode 100755 index 00000000..c7afd6f3 --- /dev/null +++ b/scripts/init-env.sh @@ -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).' diff --git a/scripts/reconcile.py b/scripts/reconcile.py new file mode 100755 index 00000000..da202dd7 --- /dev/null +++ b/scripts/reconcile.py @@ -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)/dev/null + exit 0 + fi +done +echo "No running api container matches TARGET_INSTANCE_ID" >&2 +exit 1 diff --git a/server.py b/server.py new file mode 100644 index 00000000..e950c0ff --- /dev/null +++ b/server.py @@ -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() diff --git a/tests/README.md b/tests/README.md index 0dfa3f89..36362570 100644 --- a/tests/README.md +++ b/tests/README.md @@ -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 +``` diff --git a/tests/attachments_security.py b/tests/attachments_security.py new file mode 100644 index 00000000..550c781b --- /dev/null +++ b/tests/attachments_security.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) diff --git a/tests/compensation_check.py b/tests/compensation_check.py new file mode 100644 index 00000000..83cc22b1 --- /dev/null +++ b/tests/compensation_check.py @@ -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) diff --git a/tests/idempotency_race.py b/tests/idempotency_race.py new file mode 100644 index 00000000..60c0cbe9 --- /dev/null +++ b/tests/idempotency_race.py @@ -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) diff --git a/tests/private_bucket_check.py b/tests/private_bucket_check.py new file mode 100644 index 00000000..07a752c1 --- /dev/null +++ b/tests/private_bucket_check.py @@ -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) diff --git a/tests/reconcile_scenarios.py b/tests/reconcile_scenarios.py new file mode 100644 index 00000000..2e7a3264 --- /dev/null +++ b/tests/reconcile_scenarios.py @@ -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() diff --git a/tests/reconcile_unit.py b/tests/reconcile_unit.py new file mode 100644 index 00000000..4227c0f7 --- /dev/null +++ b/tests/reconcile_unit.py @@ -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'])) diff --git a/tests/s3_failure.py b/tests/s3_failure.py new file mode 100644 index 00000000..9f06c939 --- /dev/null +++ b/tests/s3_failure.py @@ -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()