1 Commits
118 changed files with 6859 additions and 67 deletions
-30
View File
@@ -1,30 +0,0 @@
PYTHON ?= python3
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence test-failover
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
check:
$(PYTHON) scripts/check_contract.py
validate:
$(PYTHON) scripts/validate_openapi.py
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
-37
View File
@@ -1,37 +0,0 @@
# Отчёт — лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
@@ -18,3 +18,23 @@ S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
MAX_UPLOAD_BYTES=10485760 MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000 MAX_IMAGE_PIXELS=40000000
# --- реализация lab4 (см. REPORT.md, «Соответствие переменных») ---
# Порты LB на хосте (только 127.0.0.1): API, api-ttl (профиль ttl), api-fault (профиль fault), статистика.
API_PORT=8080
API_TTL_PORT=8081
API_FAULT_PORT=8082
LB_STATS_PORT=8404
API_CPUS=1.0
API_MEMORY=512M
PG_CPUS=1.0
PG_MAX_CONNECTIONS=100
SESSION_CACHE=redis
SESSION_CACHE_TTL_SECONDS=60
DB_POOL_MAX=10
KDF_CONCURRENCY=4
SHUTDOWN_DRAIN_SECONDS=3
LB_SERVER_MAXCONN=10
LB_QUEUE_TIMEOUT=2s
# Загрузки: одновременных на реплику; grace period очистки незавершённых загрузок (с).
UPLOAD_CONCURRENCY=16
UPLOAD_GRACE_SECONDS=900
+11
View File
@@ -0,0 +1,11 @@
# Shell-скрипты и файлы, читаемые внутри Linux-контейнеров, — всегда LF (иначе ломаются на Windows с autocrlf).
*.sh text eol=lf
*.sql text eol=lf
*.py text eol=lf
*.yaml text eol=lf
*.yml text eol=lf
Dockerfile text eol=lf
.env.example text eol=lf
# Windows-обёртки
*.cmd text eol=crlf
*.ps1 text eol=crlf
+40
View File
@@ -0,0 +1,40 @@
name: Application stack
# Отдельный job решения: сборка образа API, Compose-стенд (LB + 2 реплики + migrate + s3-init + PostgreSQL +
# Redis + SeaweedFS S3), публичные smoke/persistence/failover и собственные проверки вложений, отказов S3 и
# reconciler (трек 2). Секреты синтетические, генерируются на лету.
on: [push, pull_request]
permissions:
contents: read
jobs:
stack:
runs-on: ubuntu-24.04
timeout-minutes: 45
steps:
- uses: actions/checkout@v4
- name: Secrets and env (synthetic)
run: ./scripts/init-secrets.sh
- name: Compose config
run: docker compose --env-file .env config --quiet
- name: Build and start
run: docker compose --env-file .env --profile ttl up -d --build --wait
- name: Public smoke via LB (incl. attachment checksum and outsider 404)
run: make test BASE_URL=http://127.0.0.1:8080
- name: Private bucket outside API
run: make s3-check
- name: Failover (stop one replica, download via the other), then restore
run: |
make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://127.0.0.1:8080
./scripts/start-replicas.sh
cat evidence/failover-hook.txt
- name: Persistence (restart LB, replicas, PostgreSQL, Redis, S3; volumes kept)
run: make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080
- name: Student tests (attachments, lab3 regression, S3/DB/Redis failures, reconciler)
run: make test-student
- name: Concurrent uploads, peak memory
run: make upload-memory
- name: Logs on failure
if: failure()
run: docker compose --env-file .env --profile ttl --profile fault logs --no-color --tail=200
- name: Stop
if: always()
run: docker compose --env-file .env --profile ttl --profile fault down -v
+34
View File
@@ -0,0 +1,34 @@
# API мессенджера lab4. Python 3.13, зависимости ставятся в venv в отдельной стадии.
ARG PYTHON_IMAGE=python:3.13.5-slim-bookworm
FROM ${PYTHON_IMAGE} AS deps
ENV PIP_NO_CACHE_DIR=1 PIP_DISABLE_PIP_VERSION_CHECK=1
WORKDIR /build
COPY requirements.txt ./
RUN python -m venv /opt/venv \
&& /opt/venv/bin/pip install --require-virtualenv --no-compile -r requirements.txt
FROM ${PYTHON_IMAGE}
ARG APP_VERSION=dev
LABEL org.opencontainers.image.version=$APP_VERSION
ENV PATH=/opt/venv/bin:$PATH \
PYTHONPATH=/app/src \
PYTHONUNBUFFERED=1 \
PYTHONDONTWRITEBYTECODE=1 \
APP_VERSION=$APP_VERSION \
APP_HOST=0.0.0.0 \
APP_PORT=8080
RUN groupadd --system --gid 10001 app \
&& useradd --system --uid 10001 --gid app --home-dir /app --shell /usr/sbin/nologin app
COPY --from=deps /opt/venv /opt/venv
WORKDIR /app
COPY migrations ./migrations
COPY src ./src
USER 10001:10001
EXPOSE 8080
STOPSIGNAL SIGTERM
HEALTHCHECK --interval=5s --timeout=3s --start-period=30s --retries=6 \
CMD ["python", "-m", "messenger", "healthcheck"]
# PID 1 — сам HTTP-процесс (exec-форма), SIGTERM даёт graceful shutdown uvicorn.
ENTRYPOINT ["python", "-m", "messenger"]
CMD ["serve"]
+115
View File
@@ -0,0 +1,115 @@
PYTHON ?= python3
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence test-failover
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
check:
$(PYTHON) scripts/check_contract.py
validate:
$(PYTHON) scripts/validate_openapi.py
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
# ---------------------------------------------------------------------------------------------
# Цели решения (lab4). Публичные цели выше не изменены.
# ---------------------------------------------------------------------------------------------
COMPOSE ?= docker compose --env-file .env
.PHONY: secrets up down ps logs destroy-data restore s3-check reconcile reconcile-apply test-student \
test-attachments test-storage-failures test-reconcile test-api test-idempotency test-expiry \
test-cache-race test-failures upload-memory reconcile-cost evidence
secrets:
./scripts/init-secrets.sh
# Единая команда запуска: LB + 2 реплики API + migrate + s3-init (one-shot) + PostgreSQL + Redis + S3.
up: secrets
$(COMPOSE) --profile ttl up -d --build --wait
ps:
$(COMPOSE) --profile ttl --profile fault ps -a
logs:
$(COMPOSE) logs --tail=100 lb api s3
# Безопасная остановка: контейнеры удаляются, volumes pgdata и s3data сохраняются.
down:
$(COMPOSE) --profile ttl --profile fault down
# НАМЕРЕННОЕ удаление учебных данных (volumes pgdata и s3data). Необратимо.
destroy-data:
@echo "This deletes ALL lab4 data volumes (PostgreSQL + S3). Type 'yes' to continue:"; read ans; [ "$$ans" = yes ]
$(COMPOSE) --profile ttl --profile fault down -v
# Вернуть реплики после make test-failover ACTION_SCRIPT=scripts/stop-one.sh
restore:
./scripts/start-replicas.sh
# Проверка приватности bucket вне API (анонимные запросы, права ключа API).
s3-check:
$(COMPOSE) exec -T api python -m messenger s3-check
# Трек 2: reconciler. По умолчанию dry-run (код 2 = есть расхождения); исправление — reconcile-apply.
reconcile:
-$(COMPOSE) exec -T api python -m messenger reconcile
reconcile-apply:
$(COMPOSE) exec -T api python -m messenger reconcile --apply
test-attachments:
$(PYTHON) student-tests/test_attachments.py
# Останавливает/запускает s3, поднимает профиль fault (api-fault, :8082). Volumes не трогает.
test-storage-failures:
$(PYTHON) student-tests/test_storage_failures.py
test-reconcile:
$(PYTHON) student-tests/test_reconcile.py
test-api:
$(PYTHON) student-tests/test_api.py
test-idempotency:
$(PYTHON) student-tests/test_idempotency.py
test-expiry:
$(PYTHON) student-tests/test_expiry.py
test-cache-race:
$(COMPOSE) run --rm --no-deps -T -v "$(CURDIR)/student-tests:/app/student-tests:ro" --entrypoint python api student-tests/test_cache_race.py
# Останавливает/запускает redis и postgres (volumes не трогает).
test-failures:
$(PYTHON) student-tests/test_failures.py
test-student: test-attachments test-api test-idempotency test-expiry test-cache-race test-storage-failures test-failures test-reconcile
# Уровень 4: ≥10 одновременных загрузок с измерением пика памяти API и S3.
upload-memory:
$(PYTHON) research/upload_memory.py --output evidence/upload-memory.json
# Трек 2: стоимость обхода reconciler (1k/5k/20k объектов).
reconcile-cost:
$(PYTHON) research/reconcile_cost.py --sizes 1000,5000,20000 --output evidence/reconcile-cost.json
evidence:
./scripts/collect-evidence.sh
+255
View File
@@ -0,0 +1,255 @@
# Отчёт — лабораторная 4
- Автор, группа: Лебедев Дмитрий Алексеевич, БВТ2302
- Целевая оценка; выбранный трек 5: **5, трек 2 «Согласованность двух хранилищ» (reconciler)**
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ:
- библиотеки: Starlette 1.7.0, uvicorn 0.54.0, psycopg 3.2.10 + psycopg_pool 3.2.6, redis-py 5.2.1, httpx 0.28.1 (+ httpcore 1.0.9, certifi); HAProxy 3.0; SeaweedFS 4.52. Тесты — только стандартная библиотека Python;
- документация: AWS S3 (PutObject, ListObjectsV2, Signature V4, `UNSIGNED-PAYLOAD`, multipart), SeaweedFS wiki (Amazon S3 API, S3 credentials/identities, `weed server` flags) и исходники 4.52 (прогрев топологии мастера `topology.IsWarmingUp`), PNG (RFC 2083 / W3C PNG 3rd ed.: чанки, CRC, фильтры, Adam7), JPEG (ITU T.81: маркеры, SOF, SOS, byte stuffing), PostgreSQL (advisory locks, `FOR KEY SHARE`, REPEATABLE READ), Go runtime `GOMEMLIMIT`;
- **ИИ:** реализация, тесты, эксперименты и этот отчёт подготовлены с помощью ИИ-ассистента Claude (Anthropic). Код других студентов не использовался.
## Запуск из чистого clone
**Вариант: Docker Compose + HAProxy + SeaweedFS.** Prerequisites: Docker Engine 24+ с Compose v2, Python 3.9+ на хосте (тесты — только stdlib), `make` (Linux/macOS; для Windows — PowerShell-скрипты ниже). Свободны `127.0.0.1:8080` (API через LB), `:8081` (api-ttl, профиль `ttl`), `:8082` (api-fault, профиль `fault`), `:8404` (статистика HAProxy). S3 на хост **не публикуется**.
**Образы (закреплены тегами):** `haproxy:3.0.5-alpine`, `python:3.13.5-slim-bookworm` (база API), `postgres:16.10-alpine`, `redis:7.4.2-alpine`, `chrislusf/seaweedfs:4.52`. API собирается из исходников репозитория.
```sh
./scripts/init-secrets.sh # secrets/* (БД, Redis, 2 пары ключей S3, s3_config.json) и .env
docker compose --env-file .env config --quiet
docker compose --env-file .env --profile ttl up -d --build --wait # = make up
# порядок старта: postgres, redis, s3 (healthy) → migrate + s3-init (one-shot, exit 0) → api ×2 → lb
make test BASE_URL=http://127.0.0.1:8080 # публичный smoke (файл, checksum, 404 постороннему)
make s3-check # private bucket вне API
make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://127.0.0.1:8080
./scripts/start-replicas.sh # = make restore
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080
make test-student # вложения, регрессия lab2/3, отказы S3/БД/Redis, компенсация, reconciler
make upload-memory # уровень 4: ≥10 одновременных загрузок, пик RAM
make reconcile # трек 2: dry-run (код 2 — есть расхождения); make reconcile-apply — исправить
make reconcile-cost # трек 2: стоимость обхода 1k/5k/20k объектов
./scripts/collect-evidence.sh # всё сразу, вывод в evidence/
make down # безопасно: контейнеры удаляются, volumes pgdata и s3data сохраняются
make destroy-data # НАМЕРЕННОЕ удаление данных PostgreSQL и S3 (down -v), с подтверждением
```
**Windows (PowerShell 5.1, без make/WSL).** Docker Desktop запущен, Python с python.org. Используйте `127.0.0.1`, а не `localhost`; команды — по одной строке (в PowerShell 5.1 нет `&&`):
```powershell
powershell -NoProfile -ExecutionPolicy Bypass -File scripts\init-secrets.ps1
docker compose --env-file .env --profile ttl up -d --build --wait
$env:NO_PROXY = '127.0.0.1,localhost'
py -3 tests\smoke.py --base-url http://127.0.0.1:8080
docker compose --env-file .env exec -T api python -m messenger s3-check
py -3 tests\resilience.py --mode failover --action-script scripts\stop-one.cmd --base-url http://127.0.0.1:8080
powershell -NoProfile -ExecutionPolicy Bypass -File scripts\start-replicas.ps1
py -3 tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://127.0.0.1:8080
py -3 student-tests\test_attachments.py
py -3 student-tests\test_storage_failures.py
py -3 student-tests\test_reconcile.py
docker compose --env-file .env exec -T api python -m messenger reconcile
powershell -NoProfile -ExecutionPolicy Bypass -File scripts\collect-evidence.ps1 # всё сразу
```
**Действия оператора:** только создание secrets. Миграции применяет one-shot `migrate`, bucket создаёт one-shot `s3-init` (оба идемпотентны; повтор — `docker compose --env-file .env run --rm --no-deps migrate` / `… s3-init`). Пароль БД и identities S3 записываются в volumes при первом старте — не удаляйте `secrets/` при живых `pgdata`/`s3data`.
> **Где собраны доказательства.** В среде разработки Docker daemon работал, но Docker Hub и PyPI были закрыты политикой сети. Поэтому `evidence/` получены на **том же `compose.yaml`** с локальными образами-заменителями: HAProxy 3.0.0 из исходников, PostgreSQL 16, Redis 7, Python 3.13 с теми же библиотеками, **SeaweedFS 4.52 — официальный бинарник релиза с GitHub** в минимальном образе. Подмена — только `image`/сборка API и форма healthcheck S3 (в заменителе нет `wget`, та же проверка сделана через `bash /dev/tcp`) в override-файле, не входящем в репозиторий; топология, сети, лимиты, флаги weed, хуки и конфиг HAProxy — те же. Перед защитой выполните `make up && ./scripts/collect-evidence.sh` (Windows: `scripts\collect-evidence.ps1`), чтобы `evidence/` содержал вывод ваших официальных образов; тот же сценарий гоняет `.github/workflows/app.yml`.
## Архитектура и решения
```
127.0.0.1:8080 / :8081 / :8082 / :8404
клиент ──HTTP──► lb: HAProxy 3.0 ──(app, internal)──► api × 2 (без ports, read_only rootfs, tmpfs /tmp)
│ │
(data, internal) ▼ ▼ (objects, internal)
postgres:16 [pgdata] s3: SeaweedFS 4.52 [s3data]
users, chats, messages, sessions, weed server: master+volume+filer
idempotency_keys, attachments, на 127.0.0.1 внутри контейнера;
message_attachments, upload_intents, наружу только S3 API :9000;
attachment_integrity bucket messenger-attachments (private)
redis:7 — кэш сессий
migrate (one-shot) → схема; s3-init (one-shot, admin-ключ) → bucket + проверки приватности
```
| Роль | Service | Образ | Health/readiness | Volume | Сеть | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| load_balancer | `lb` | `haproxy:3.0.5-alpine` | бэкенды — `/health/ready` | — | edge+app; `127.0.0.1:8080/8081/8082/8404` | — |
| api | `api` (`deploy.replicas: 2`) | сборка `Dockerfile` | `/health/ready` (PostgreSQL; S3 и Redis — нет, см. ниже) | **нет** | app+data+objects, портов нет | `database_url`, `cache_url`, `s3_access_key_id`, `s3_secret_access_key` (identity `messenger-api`) |
| migrations | `migrate` (one-shot) | образ API | exit 0 — условие старта api | — | data | `database_url` |
| object_storage | `s3` | `chrislusf/seaweedfs:4.52` | S3 `/healthz` **и** master `/cluster/healthz` **и** `/dir/assign` выдаёт fid (запись возможна) | `s3data` | objects (internal) | `s3_config` (identities) |
| s3 bootstrap | `s3-init` (one-shot) | образ API, `s3-bootstrap` | exit 0 — условие старта api | — | objects | **admin**-ключ (только здесь) + ключ API для проверки его прав |
| postgres / redis | как в lab3 | `postgres:16.10-alpine` / `redis:7.4.2-alpine` | `pg_isready` / `PING` | `pgdata` / — | data | secrets |
| api-ttl / api-fault | профили `ttl` / `fault` | образ API | как api | — | как api; только через LB `:8081` / `:8082` | как api |
**Что перенесено из lab3** без изменений семантики: весь API, сессии (PostgreSQL — источник истины, Redis — кэш с outbox), идемпотентность `POST /messages`, stateless-реплики, `X-Instance-Id`, HAProxy с проверками/`retry-on conn-failure`/panic mode/очередью, SIGTERM-drain, one-shot миграции, rolling update с expand-only миграциями. Все тесты lab2/lab3 запускаются и проходят (таблица ниже). **Что добавлено в lab4:**
1. **SeaweedFS** как S3-сервер в общем стенде (выбор: один бинарник, Apache-2.0, S3 identities с правами на bucket; MinIO-образы сообщества заморожены). `weed server` запускает master, volume, filer и S3-шлюз в одном процессе. Master/volume/filer и их **web-консоли слушают только `127.0.0.1` внутри контейнера** (`-ip.bind=127.0.0.1`), наружу из контейнера доступен лишь S3 API `:9000`, и только из internal-сети `objects`, в которой нет LB. Ни одного порта S3 на хосте.
2. **Две identity** (`secrets/s3_config.json`, генерирует `init-secrets`): `admin` — только у `s3-init`; `messenger-api` — `Read/Write/List:messenger-attachments` (не может создавать/удалять бакеты, читать другие бакеты). Анонимного доступа нет.
3. **Bootstrap bucket** — `python -m messenger s3-bootstrap` в `s3-init`: ждёт S3 (≤ 60 с), `CreateBucket` (уже есть → «не создан», ошибки нет), затем проверки приватности (анонимные ListObjects/GetObject/PutObject/ListBuckets → 403; ключ API: List своего bucket — разрешён, CreateBucket — `AccessDenied`). Любая непройденная проверка → exit 1 → API не стартует. Та же проверка «вне API» — `make s3-check`.
4. **Миграция `0004_attachments.sql`** (expand-only): `attachments`, `message_attachments`, `upload_intents`, `attachment_integrity`; ограничение текста сообщения стало `≤ 4000` (пустой текст допустим только с вложениями — проверка в приложении).
5. **Свой S3-клиент** (`src/messenger/s3.py`, SigV4 поверх httpx): нужен потоковый PUT с известным `Content-Length` без буферизации файла и потоковый GET → HTTP-ответ.
6. **Потоковый валидатор изображений** (`src/messenger/imagecheck.py`) и pipeline загрузки (ниже).
7. **Компенсация** (intent log + janitor) и **reconciler** трека 2 (`src/messenger/reconcile.py`).
### Модель данных
`attachments(id, chat_id → chats, owner_id, filename, content_type, size_bytes, sha256, width, height, object_key UNIQUE, status='ready', created_at, updated_at)`. **Вложение принадлежит чату**: загружать может только участник, использовать в сообщении — только в том же чате. `message_attachments(message_id → messages ON DELETE CASCADE, attachment_id → attachments **без CASCADE**, position 0–9)` сохраняет порядок `attachment_ids`. **Object key назначает сервер**: `attachments/<uuid4 hex>`; filename (1–255 символов, без `/ \ NUL`, управляющих C0/C1, bidi-override `U+202A–202E, U+2066–2069`, `U+200E/F`, `U+2028/9`, BOM; не «.»/«..») используется только для отображения и `Content-Disposition: filename*=UTF-8''…`.
### Upload: когда можно честно вернуть 201
`POST /api/v1/chats/{id}/attachments?filename=…`, тело — сырые байты одного файла:
1. **До чтения тела**: Bearer → чат существует и пользователь — участник (иначе **404**, тело не читается: посторонний не заставит принимать 10 МиБ) → filename → `Content-Type ∈ {image/png, image/jpeg}` (иначе 415) → обязателен `Content-Length` (chunked → 400), `> MAX_UPLOAD_BYTES` → **413 сразу**, `0` → 415 → слот `UPLOAD_CONCURRENCY` (16 на реплику; ждать ≤ 5 с, иначе 503).
2. `INSERT upload_intents(object_key, …)` — **отдельной транзакцией до записи в S3**.
3. Тело читается кусками (≈ 64 КиБ). Первые байты: формат по magic (PNG/JPEG) обязан совпасть с `Content-Type` (подмена → 415). Каждый кусок → валидатор → SHA-256 → **сразу в S3 PUT** (`UNSIGNED-PAYLOAD`, известная длина). В RAM — только текущий кусок и состояние валидатора.
4. Валидатор **без декодирования в память**: PNG — сигнатура, порядок/CRC всех чанков, поля IHDR, `width×height ≤ MAX_IMAGE_PIXELS` **по заголовку** (413 до пиксельных данных), поток IDAT реально распаковывается zlib порциями ≤ 1 МиБ, и объём обязан **точно** совпасть с ожидаемым по размерам (с учётом Adam7) — «zip-бомба» отсекается на первом лишнем мегабайте; IEND и отсутствие мусора после него. JPEG — структура маркеров, SOF с размерами (лимит пикселей), SOS-сканирование entropy-данных (stuffing/RST) до обязательного EOI.
5. Ошибка валидатора или обрыв клиента **обрывает PUT до конца тела** — S3 не фиксирует объект с неполным `Content-Length`; компенсация удаляет ключ на всякий случай и снимает intent.
6. PUT подтверждён → **одна транзакция**: `INSERT attachments` + `DELETE upload_intents`. **201 возвращается только после COMMIT** — то есть когда байты в S3 и метаданные в PostgreSQL. Обратного порядка (сначала строка, потом объект) нет: иначе видимое вложение могло бы не иметь байтов.
Download `GET /attachments/{id}/content?variant=original`: Bearer → участник чата вложения (иначе 404 и для метаданных, и для байтов) → потоковый S3 GET → ответ с `Content-Length`, `ETag: "sha256"`, `X-Content-Type-Options: nosniff`, `Cache-Control: private, no-store`. Неизвестный `variant` → 400, `thumbnail` в lab4 → 404. S3 недоступен → 503; объект утрачен при живых метаданных → 500 «Содержимое вложения утрачено» (не маскируется под 404).
`POST /messages` с `attachment_ids`: ≤ 10 уникальных UUID; в одной транзакции с сообщением проверяется, что **все** вложения принадлежат этому чату (`SELECT … FOR KEY SHARE` — reconciler не удалит строку между проверкой и вставкой); чужое/неизвестное → 404 с откатом. `attachment_ids` входит в отпечаток идемпотентности (другой порядок с тем же ключом → 409).
### Согласованность S3 ↔ PostgreSQL (уровень 4)
| Отказ | Что остаётся | Кто чистит |
| --- | --- | --- |
| Неверный файл, лимит, обрыв клиента, таймаут | PUT оборван (объекта нет); intent | Сразу: компенсация удаляет ключ и intent (`compensations`) |
| То же при недоступном S3 | intent (возможно, объект) | janitor после grace |
| Процесс убит **между S3 PUT и COMMIT** (FAULT_INJECT, `os._exit(137)`) | объект + intent, метаданных нет | **janitor**: каждые `JANITOR_INTERVAL_SECONDS`, под `pg_try_advisory_lock` (одна реплика), intents старше `max(UPLOAD_GRACE_SECONDS, UPLOAD_TIMEOUT_SECONDS + 5)` → удалить объект, если нет строки `attachments`, снять intent |
| Ручное вмешательство, восстановление из backup, ошибки на любой стороне | orphan/missing любого вида | **reconciler** (трек 2) |
Grace period безопасен: intent нельзя считать брошенным, пока запрос ещё может законно идти (`UPLOAD_TIMEOUT_SECONDS` = 120 с ограничивает весь handler), поэтому нижняя граница — `timeout + 5`; по умолчанию 900 с.
### Деградация при отказе S3
S3 **не входит в readiness**: без него недоступны только вложения (503 за ~10 мс, connect-timeout 2 с), а текст, сессии, история и метаданные вложений работают. Иначе отказ S3 вывел бы из LB все реплики. После старта SeaweedFS чтение возвращается раньше записи: мастер ~15 с «прогревает» топологию (в 4.52 зашито `pulse 5 s × 3`, флага нет). Поэтому healthcheck `s3` требует, чтобы `/dir/assign` выдал fid, а `restart.sh` ждёт healthy S3 перед стартом API.
### Ресурсы и память
| Компонент | Лимит | Что ограничивает RAM |
| --- | --- | --- |
| api (×2) | `API_CPUS`/`API_MEMORY` = 1 CPU / 512 MiB | потоковая обработка; `UPLOAD_CONCURRENCY=16`; LB `maxconn 10` + очередь 2 с на реплику |
| s3 | 1 CPU / 1 GiB | `GOMEMLIMIT=640MiB`, `-s3.concurrentFileUploadLimit=8`, `-{s3,filer,volume}.concurrentUploadLimitMB=96`, `-s3.cacheCapacityMB=32` — без них 10 одновременных загрузок по 10 МиБ привели к OOM-kill weed (эксперимент ниже) |
Остальное — как в lab3. Также `-master.telemetry=false` (weed по умолчанию шлёт статистику во внешний интернет), быстрая остановка (`stop_signal: SIGINT`, `-volume.preStopSeconds=1`: было 10 с впустую на каждом рестарте).
### Соответствие переменных `.env.example`
`S3_ENDPOINT`, `S3_REGION`, `S3_BUCKET`, `S3_ACCESS_KEY_ID_FILE`/`S3_SECRET_ACCESS_KEY_FILE` (ключи identity `messenger-api`), `MAX_UPLOAD_BYTES` (10 485 760), `MAX_IMAGE_PIXELS` (40 000 000) — как названы. Дополнительно: `API_FAULT_PORT`, `UPLOAD_CONCURRENCY`, `UPLOAD_GRACE_SECONDS`; в `compose.yaml` — `UPLOAD_TIMEOUT_SECONDS=120`, `JANITOR_INTERVAL_SECONDS=60`, `S3_TIMEOUT_SECONDS` (30, по умолчанию). Admin-ключ (`S3_ADMIN_*_FILE`) есть только у `s3-init`. Переменные lab3 — как в lab3.
## Доказательства критериев
Все файлы — в `evidence/`. Стенд — см. примечание выше; версии и контейнеры — `evidence/stack.txt`. Прогон с **пустых volumes** `pgdata` и `s3data`.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл |
| --- | --- | --- | --- |
| Публичный smoke (файл, SHA-256, 404 постороннему) | `tests/smoke.py --base-url http://127.0.0.1:8080` | `PASS: lab4 public API scenario` | `smoke.txt` |
| 3: S3 в общем стенде; метаданные в PostgreSQL, байты в приватном bucket, не в БД и не у API | `compose up --wait`; `docker inspect` реплик | `s3`, `s3-init` (exit 0), `migrate` (exit 0), `api` ×2, `lb`; у API `ReadonlyRootfs=true`, `/tmp` — tmpfs (там только `instance-id`), монтирования — только 4 secret-файла, запись в `/app` → `Read-only file system` | `stack.txt`, `api-no-local-files.txt` |
| 3: версия S3 закреплена, приватный bucket создаётся описанно | `chrislusf/seaweedfs:4.52`; one-shot `s3-init` | первый запуск `"created": true`, повтор `"created": false`, проверки приватности 6/6 | `s3-bootstrap.txt`, `s3-bootstrap-rerun.txt` |
| 3: POST → 201 ready после сохранения; оригинал побайтно; message с attachment_ids читается участниками | smoke; `test_attachments.py` | PNG и JPEG: `sha256`/`size` совпадают, второй участник скачивает байт-в-байт, `Content-Type`/`nosniff`/`Content-Length`; сообщение с пустым текстом и вложением | `smoke.txt`, `test-attachments.txt` |
| 3: реальные PNG/JPEG ≤ 10 MiB и ≤ 40 Мп; MIME по содержимому; опасные filename; лимиты до неограниченного чтения/декодирования | `test_attachments.py` | файл 10.00 MiB — 201; `Content-Length` 50 MiB — **413 за 4 мс, тело не отправлялось**; 8000×6000 (PNG) и 7000×7000 (JPEG) — 413 по заголовку за 51 мс; zlib-бомба 65 KB → «64 MiB» — 415 за 22 мс; 11 опасных filename — 400 | `test-attachments.txt` |
| 3: upload → остановка обслужившей реплики → download через другую | `tests/resilience.py --mode failover --action-script scripts/stop-one.sh` ×2 | PASS дважды: 2 реплики до отказа, 135 и 137 записей, 0 неудачных, оригинал прочитан через оставшуюся реплику; `first_recovery_seconds` 5.5 / 5.2 (время работы хука, записи не прерывались) | `failover-1.txt`, `failover-2.txt`, `failover-hook.txt` |
| 3: restart с сохранением volumes сохраняет метаданные и оригинал | `tests/resilience.py --mode persistence --action-script scripts/restart.sh` | PASS тем же токеном, оригинал совпал; новые `StartedAt`/PID у LB, обеих реплик, PostgreSQL, Redis **и s3**; volumes `pgdata`, `s3data` на месте | `persistence.txt`, `restart-hook.txt` |
| 3: проверка недоступности S3, чужого чата | `test_storage_failures.py`, `test_attachments.py` | см. строки ниже | — |
| 4: слишком большой файл, повреждённое изображение, подмена MIME, чужое attachment_id, файл другого чата; пользовательская ошибка ≠ 500 | `test_attachments.py` (13 сценариев) | 413/415/400/404 из контракта во всех вариантах (9 повреждённых, 8 подмен MIME, вложение другого чата того же владельца → 404, неизвестный ID → 404, >10/дубли → 400); 500 нет ни разу (клиент проверяет код и формат Error) | `test-attachments.txt` |
| 4: прерывание загрузки и отказ между S3/БД не оставляют вечных объектов; grace period | `test_storage_failures.py` | обрыв на 1/3 и за 1 байт до конца: объектов и intents столько же, сколько было; `api-fault` (`os._exit` после PUT): intent записан, объект есть, метаданных нет → janitor удалил объект и intent через 15.0 с (grace 10 с) | `test-storage-failures.txt` |
| 4: лимиты/таймауты/потоковость — RAM одной загрузки ограничена; ≥10 одновременных загрузок с пиком памяти | `research/upload_memory.py` | 10/20/32 одновременных по 10 MiB: пик RSS реплики +1.3/+3.3/+2.7 MiB (при буферизации было бы +50/+99/+159 MiB); медленные клиенты 10/20 — +0.0/+0.1 MiB; S3 ≤ 493 MiB анонимной памяти | `upload-memory.json`, `upload-memory.txt` |
| 4: bootstrap идемпотентен; отдельные ограниченные credentials API; консоль не в общей сети; private bucket вне API | `s3-init` ×2; `make s3-check`; анонимный GET существующего ключа | анонимные List/Get/Put/ListBuckets → 403, анонимный GET реального объекта → 403; ключ API: List своего bucket — да, CreateBucket — `AccessDenied`; master/volume/filer слушают 127.0.0.1 внутри контейнера, S3 только в internal-сети `objects`, портов на хосте нет | `s3-check.txt`, `s3-bootstrap*.txt`, `test-storage-failures.txt`, `compose.yaml` |
| 4: недоступность S3 | `test_storage_failures.py` (stop s3) | upload/download → 503 за 0.01 с; текстовые сообщения, метаданные вложений, `/health/ready` — работают; после старта чтение вернулось через 3.6 с, запись — через 22.8 с (прогрев SeaweedFS); данные целы | `test-storage-failures.txt` |
| 5, трек 2 | `student-tests/test_reconcile.py`, `research/reconcile_cost.py` | 7/7 сценариев; см. раздел трека | `test-reconcile.txt`, `reconcile-cost.json`, `reconcile-dry-run.txt` |
| Сохранены возможности lab2/lab3 | `test_api.py`, `test_idempotency.py`, `test_expiry.py` (LB :8081), `test_cache_race`, `test_failures.py` (Redis/PostgreSQL down) | 18/18, 9/9, 3/3, all passed, 2/2 | `test-api.txt`, `test-idempotency.txt`, `test-expiry.txt`, `test-cache-race.txt`, `test-failures.txt` |
| Миграции однократно; повтор — no-op | пустой volume → `migrate`; `run --rm migrate` | `applied: [0001…0004]` один раз (одна строка на версию в `schema_migrations`), повторы — `applied: []` | `migrations.txt`, `migrations-rerun.txt` |
| Нагрузка (профиль lab3 регрессия) | `tests/load.py --duration 30 --concurrency 4` | 251.1 успешных RPS, 0 ошибок, p50/p95/p99 = 14.0/30.6/47.0 мс | `load.json` |
| `make check` | `scripts/check_contract.py` | PASS | `make-check.txt` |
## Эксперименты и отказы
Стенд: 2 vCPU, 8 GiB RAM, Docker 29.9.2, Compose 5.6.1 (`stack.txt`); лимиты — как в `compose.yaml` (API 1 CPU / 512 MiB ×2, S3 1 CPU / 1 GiB).
| Воздействие | Что ожидаем | Что наблюдали | Восстановление / потеря данных |
| --- | --- | --- | --- |
| `docker stop` реплики, обслужившей тест (×2, каждая) | LB за ≈ 2 с исключает реплику, файл скачивается через другую | 0 неудачных записей из 135/137, оригинал совпал | записи не прерывались; потерь 0 |
| restart всего стенда (LB, API, PostgreSQL, Redis, S3), volumes сохранены | метаданные, байты и сессия переживают | PASS тем же токеном; новые PID у всех; хук ждёт healthy S3 (с записью) | хук ≈ 36 с; потерь 0 |
| `stop s3` | вложения 503 быстро, остальное работает, readiness не падает | 503 за 0.01 с; текст/история/метаданные/ready — 200 | чтение через 3.6 с, запись через 22.8 с после `start`; потерь 0 |
| Обрыв клиента посреди тела (1/3 и n−1 байт) | PUT обрывается, ничего не остаётся | объектов и intents не прибавилось | мгновенно (компенсация) |
| Падение процесса между S3 PUT и COMMIT (`FAULT_INJECT=crash_after_s3_put`) | клиент не получает 201; orphan удаляется после grace | клиент — 502 (соединение оборвано); intent+объект → удалены janitor | 15.0 с при grace 10 с |
| Redis down / PostgreSQL down (регрессия lab3) | кэш не критичен; без БД — ограниченный 503 | fallback 18 мс; без БД 503 за ≤ 2 с | автоматически |
**Эксперимент: пик памяти при одновременных загрузках (уровень 4).** *Гипотеза:* pipeline потоковый (кусок ≈ 64 КиБ → валидатор → SHA-256 → S3 PUT), поэтому пик RSS реплики растёт на O(N × буфер), а не на O(N × размер файла). *Методика* (`research/upload_memory.py`, повторяемо): перед каждым сценарием сбросить VmHWM обеих реплик (`python -m messenger stats --reset-peak` → `/proc/self/clear_refs`), N потоков шлют через LB несжимаемый PNG 9.94 MiB сырым сокетом (fast — без пауз; slow — по 64 КиБ со скоростью 2 MiB/с, соединение держит слот ≈ 5 с), затем читаются VmHWM/VmRSS реплик; память S3 — анонимная память cgroup (`memory.stat`), опрос каждые 0.2 с.
| N одновременно | Клиент | 201 | Время, с | Пик RSS реплики, MiB (до → пик) | Прирост пика | Если бы буферизовали (на реплику) | S3, MiB |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 1 | fast | 1/1 | 0.26 | 60 → 60 | +0.0 | 5.0 | 172 |
| 10 | fast | 10/10 | 2.02 | 61 → 62 | +1.3 | 49.7 | 492 |
| 20 | fast | 20/20 | 3.43 | 61 → 64 | +3.3 | 99.3 | 493 |
| 32 | fast | 25/32 | 4.62 | 62 → 64 | +2.7 | 159.0 | 493 |
| 10 | slow 2 MiB/с | 10/10 | 5.39 | 62 → 62 | +0.0 | 49.7 | 487 |
| 20 | slow 2 MiB/с | 20/20 | 7.06 | 62 → 62 | +0.1 | 99.3 | 473 |
*Вывод:* гипотеза подтверждена — прирост пика RSS API ≤ 3.3 MiB при 20 одновременных 10-MiB загрузках (в 30 раз меньше буферизации). При N = 32 > 2 × `LB_SERVER_MAXCONN` 7 запросов получили 503 от LB через 2 с ожидания в очереди (`sQ` в логе HAProxy, JSON-ошибка с `Retry-After`) — это ограничение конкуренции lab3, а не отказ. *Находка в ходе эксперимента:* первая версия стенда (S3 512 MiB, без лимитов) на 10 одновременных загрузках **уронила SeaweedFS по OOM** (в `dmesg`: `Memory cgroup out of memory: Killed process (weed) anon-rss:521856kB`), все загрузки получили 503. Лимиты weed по MB в 4.52 память не ограничили (OOM повторился на 1 GiB); помогли `GOMEMLIMIT=640MiB` + `-s3.concurrentFileUploadLimit=8`: S3 держится около 490 MiB, перезапусков 0. *Ограничения:* VmHWM — пик процесса за интервал между замерами, `docker exec` добавляет ≈ 0.3 с к границам; один хост, клиент и стенд делят 2 vCPU; S3 измеряется опросом (короткие пики < 0.2 с могли быть пропущены).
## Трек 2. Согласованность двух хранилищ
**Гипотеза.** Повторяемый обход «снимок S3 → снимок БД → точечная перепроверка перед действием» находит все расхождения обоих направлений и исправляет безопасные из них, не трогая свежие и используемые вложения даже при параллельных загрузках; стоимость обхода — O(N/1000) запросов List для режима без checksum и O(N) GET с ним.
**Инструмент.** `python -m messenger reconcile` (в контейнере API: `make reconcile` / `make reconcile-apply`); по умолчанию **dry-run** (только отчёт, код 2 — есть что исправлять); `--apply`, `--grace-seconds` (по умолчанию `UPLOAD_GRACE_SECONDS` = 900), `--verify-checksums`, `--prefix`, `--json`. Один экземпляр с janitor одновременно (общий `pg_advisory_lock`). Отчёт — JSON: счётчики классов, примеры ключей, действия, стоимость (время фаз, число S3-запросов, пик RSS).
**Почему порядок обхода безопасен.** (1) `t0 = clock_timestamp()` БД, затем ListObjectsV2 + список незавершённых multipart; (2) **после** листинга — снимок `attachments` (с флагом «есть ссылки из сообщений») и `upload_intents` **одной REPEATABLE READ-транзакцией**. Загрузка пишет intent *до* PUT и снимает его *в той же транзакции*, что создаёт метаданные, — значит, любой объект из листинга виден либо как строка, либо как intent, либо он действительно orphan; объект, появившийся после листинга, в обход не попадает. (3) Перед каждым разрушающим действием условие перепроверяется точечно (строка/intent появились? объект вернулся — HEAD?), строка вложения блокируется `FOR UPDATE`, `DELETE … WHERE NOT EXISTS (ссылок)` плюс FK без CASCADE; создание сообщения берёт `FOR KEY SHARE` на свои вложения. (4) Intent считается брошенным только старше `max(grace, UPLOAD_TIMEOUT_SECONDS + 5)` — живая загрузка физически не может длиться дольше таймаута handler.
| Класс | Условие | `--apply` |
| --- | --- | --- |
| `ok` | объект есть, размер совпадает (+ SHA-256 при `--verify-checksums`) | — |
| `orphan` | объект без строки и без intent, `LastModified` старше grace | удалить объект |
| `orphan_fresh` | то же, моложе grace | не трогать |
| `in_progress` | объект/ключ с intent моложе intent-grace | не трогать |
| `stale_intent` | intent старше intent-grace (с объектом или без) | удалить объект, если нет метаданных; снять intent |
| `missing_unreferenced` | строка есть, объекта нет, ссылок нет, старше grace | удалить строку (вложение всё равно нельзя использовать) |
| `missing_referenced` | объекта нет, вложение в сообщениях | **метаданные не удалять**, флаг `attachment_integrity = missing_object` |
| `missing_fresh` | объекта нет, моложе grace | не трогать |
| `size_mismatch` / `checksum_mismatch` | размер / SHA-256 не совпадает | флаг, данные не удаляются |
| `flag_resolved` | флаг есть, но объект снова цел (восстановлен из backup) | снять флаг; без `--verify-checksums` флаг checksum не снимается |
| `multipart_stale` | незавершённая multipart старше grace | abort |
**Методика внедрения ошибок** (`student-tests/test_reconcile.py`, grace = 60 с): в обход API. *Сторона S3* (admin-ключом из контейнера `s3-init`, `student-tests/s3_admin.py`): удалить объект используемого вложения; удалить объект неиспользуемого; испортить байт (тот же размер); усечь объект; подбросить посторонний объект. *Сторона БД* (psql): удалить строку `attachments` (объект осиротел); intent «упали после PUT» (с объектом) и «упали до PUT» (без объекта), возраст 5 мин (старше порога reconciler 125 с, но моложе 900 с janitor, иначе их раньше уберёт сам API). *Контроль:* используемое и неиспользуемое здоровые вложения; затем, после ожидания grace, свежие дефекты — свежий orphan, живая загрузка (intent + объект), свежее вложение без объекта, свежее используемое.
**Результаты** (`test-reconcile.txt`, 7/7 PASS, чистый volume):
1. **dry-run** (код 2) классифицировал все 14 внедрённых случаев правильно (`orphan` ×2, `stale_intent` ×2, `missing_referenced`, `missing_unreferenced`, `checksum_mismatch`, `size_mismatch`, `orphan_fresh`, `in_progress`, `missing_fresh`) и **ничего не изменил** (число строк, intents, флагов и объектов то же).
2. **`--apply`:** `deleted_orphan_object 2, deleted_stale_upload_object 2, removed_stale_intent 2, deleted_lost_metadata 1, flagged_missing_object 1, flagged_checksum_mismatch 1, flagged_size_mismatch 1`. Используемые вложения с проблемами остались в истории (метаданные 200, флаг в `attachment_integrity`); утраченный объект при download даёт 500, а не подменяется. Все контрольные и свежие объекты целы, SHA-256 скачанных совпали.
3. **Свежее защищено ровно до grace:** через 70 с после создания свежий orphan удалён и свежая потерянная строка удалена, а объект живой загрузки (intent моложе 125 с) **остался**.
4. **Повторный запуск идемпотентен:** dry-run — код 0, `actionable_found = {}`; `--apply` — `actions = {}`, состояние не изменилось; помеченные проблемы по-прежнему видны в отчёте, но не порождают действий.
5. **Восстановление из backup:** объект вернули → `flag_resolved` → `--apply` снял флаг, download снова 200 с прежними байтами.
6. **Гонка с живым трафиком, grace = 0 (худший случай):** 6 потоков 12 с загружали файлы и (через раз) отправляли сообщения, параллельно 6 раз подряд `reconcile --apply --grace-seconds 0`: 849 загрузок, **0 потерянных или повреждённых** (каждое скачано и сверено по SHA-256).
**Стоимость обхода** (`research/reconcile_cost.py`, объекты по 4 KiB в отдельном префиксе, согласованные строки через COPY; время — внутри процесса reconciler, без старта `docker exec` ≈ 0.7 с):
| N объектов | dry-run, с (List S3 / снимок БД) | S3-запросов | Пик RSS, MiB | `--verify-checksums`, с / запросов | Исправление N orphan: `--apply`, с / запросов |
| --- | --- | --- | --- | --- | --- |
| 1 000 | 0.11 (0.07 / 0.03) | 2 | 59 | 2.56 / 1 002 | 5.4 / 2 002 |
| 5 000 | 0.43 (0.23 / 0.20) | 6 | 62 | 13.6 / 5 006 | 28.4 / 10 006 |
| 20 000 | 1.45 (0.76 / 0.64) | 21 | 80 | — | 104.4 / 40 021 |
После каждого `--apply` повторный dry-run того же префикса пуст (код 0). *Вывод:* обход без checksum линеен и дёшев — ≈ 72 мкс и 0.001 S3-запроса на объект (1 List на 1000 ключей), 20 000 объектов за 1.5 с; память растёт на ≈ 1 MiB на 1000 объектов (оба снимка в памяти). Проверка SHA-256 стоит ≈ 2.6 мс и 1 GET на объект (≈ 400 объектов/с для 4 KiB, для 10 MiB определяется пропускной способностью S3) — её разумно запускать реже (например, раз в сутки по части префикса). Исправление orphan — 2 запроса (HEAD-перепроверка + DELETE) и ≈ 5 мс на объект последовательно.
**Ограничения.** Снимки держатся в памяти процесса (для 10⁶–10⁷ объектов нужен постраничный обход по диапазонам ключей с курсором и тем же порядком «S3, потом БД»). Время `LastModified` берётся из S3, `t0` — из PostgreSQL: допустимая рассинхронизация часов должна быть много меньше grace (на одном хосте ≈ 0). Reconciler доверяет листингу S3: SeaweedFS отдаёт консистентный листинг через filer, но у eventual-consistent хранилищ нужен больший grace. Время измерено на 2 vCPU с S3 на том же хосте; при сетевом S3 стоимость обхода определяется числом запросов, а оно в таблице.
## Ответы на вопросы защиты
- **Почему файл в Docker volume одной API-реплики не равен объектному хранилищу?** Volume привязан к контейнеру/хосту реплики: вторая реплика его не видит (download после остановки загрузившей сломается), при пересоздании/переносе задачи он теряется или расходится, нет общего контроля доступа, листинга, сверки и жизненного цикла. S3 — отдельная общая служба со своим volume, к которой ходят все реплики. У нас rootfs API `read_only`, `/tmp` — tmpfs, volumes у API нет вовсе (`api-no-local-files.txt`), и failover-тест скачивает файл через другую реплику.
- **Когда можно честно вернуть 201?** Только после того, как S3 подтвердил PUT (байты целиком, размер и SHA-256 посчитаны по тому, что ушло в S3) **и** закоммичена транзакция с метаданными. До этого — никакого 201: обрыв/ошибка/таймаут дают 4xx/5xx, а intent гарантирует уборку.
- **Что, если S3 PUT прошёл, а COMMIT в PostgreSQL — нет?** Клиент не получает 201 (повторит загрузку), а в S3 остаётся объект без метаданных. Его ключ уже записан в `upload_intents` до PUT, поэтому janitor после grace удалит объект и intent; тест `test_storage_failures` убивает процесс ровно в этой точке и видит уборку за ≈ 15 с при grace 10 с. Если intent тоже потерян (ручное вмешательство, восстановление БД из старого backup), объект найдёт reconciler как orphan.
- **Почему случайный object key и приватный bucket не заменяют ACL приложения?** Ключ — не секрет (виден в логах, бэкапах, админке, может утечь), а приватный bucket лишь закрывает прямой анонимный доступ к S3. Кто из пользователей видит какое вложение, знает только приложение: участник ли он чата, удалён ли он из чата и т. п. Поэтому каждый download проходит авторизацию и проверку членства в API (посторонний получает 404 и на метаданные, и на байты), а у ключа API в S3 права только на свой bucket.
## Ограничения и следующие шаги
- **Один узел SeaweedFS без репликации** (`replication 000`): потеря volume `s3data` = потеря байтов (метаданные останутся, reconciler пометит их `missing_object`). Для production — кластер из ≥ 3 master и volume-серверов с репликацией и бэкапами; это вне рамок лабораторной.
- **JPEG проверяется структурно** (маркеры, SOF, entropy-поток до EOI), без полного Huffman-декодирования: тонкие ошибки внутри entropy-данных не отсекаются. PNG проверяется полностью (CRC + реальная распаковка с контролем объёма).
- **Нет антивирусной проверки и перекодирования**; оригинал отдаётся как есть, но с `nosniff` и проверенным по содержимому `Content-Type`. Thumbnail — lab5.
- **Upload только с `Content-Length`** (chunked → 400): это осознанное решение ради раннего 413 и потокового PUT с известной длиной.
- Подпись `UNSIGNED-PAYLOAD`: целостность канала до S3 не подписывается (внутренняя сеть). Сравнение `size` при reconcile и SHA-256 при `--verify-checksums` закрывают тихую порчу, но не атакующего внутри сети `objects` — это задача mTLS (lab7).
- Под нагрузкой > 2 × `LB_SERVER_MAXCONN` одновременных загрузок излишек получает 503 от LB через 2 с (`Retry-After: 1`) — это ограничение конкуренции, а не отказ; клиентам нужен повтор.
- После рестарта S3 запись недоступна ≈ 15–20 с (прогрев мастера SeaweedFS); загрузки в это окно ждут (до `S3_TIMEOUT_SECONDS`), а не падают.
- Reconciler запускается вручную/по расписанию (`make reconcile`, cron/CI), не непрерывно; при очень больших bucket листинг стоит O(N) запросов по 1000 ключей (см. трек 2).
+294
View File
@@ -0,0 +1,294 @@
# Учебный стенд lab4: HAProxy (единственная точка входа) → API × N → PostgreSQL (метаданные)
# + приватный S3 bucket в SeaweedFS (байты вложений) + Redis (кэш сессий).
# Запуск: ./scripts/init-secrets.sh && docker compose --env-file .env up -d --build --wait
name: mtusi-lab4
x-api-common: &api-common
build:
context: .
dockerfile: Dockerfile
image: mtusi-lab4-api:local
environment: &api-env
APP_HOST: 0.0.0.0
APP_PORT: "8080"
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: postgres
SESSION_CACHE: ${SESSION_CACHE:-redis}
SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
DB_POOL_MIN: "1"
DB_POOL_MAX: ${DB_POOL_MAX:-10}
DB_POOL_TIMEOUT_SECONDS: "2"
KDF_CONCURRENCY: ${KDF_CONCURRENCY:-4} # каждый scrypt ≈ 32 MiB RAM: учитывайте в API_MEMORY
DB_STATEMENT_TIMEOUT_MS: "5000"
CACHE_TIMEOUT_SECONDS: "0.2"
REQUEST_TIMEOUT_SECONDS: "10"
SHUTDOWN_DRAIN_SECONDS: ${SHUTDOWN_DRAIN_SECONDS:-3}
MIGRATE_ON_START: "false" # миграции — только сервис migrate
# S3: отдельная identity API с правами Read/Write/List ТОЛЬКО на свой bucket (не admin).
S3_ENDPOINT: http://s3:9000
S3_REGION: ${S3_REGION:-us-east-1}
S3_BUCKET: ${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: ${MAX_UPLOAD_BYTES:-10485760}
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
UPLOAD_CONCURRENCY: ${UPLOAD_CONCURRENCY:-16}
UPLOAD_TIMEOUT_SECONDS: "120"
UPLOAD_GRACE_SECONDS: ${UPLOAD_GRACE_SECONDS:-900}
JANITOR_INTERVAL_SECONDS: "60"
secrets: [database_url, cache_url, s3_access_key_id, s3_secret_access_key]
depends_on:
migrate:
condition: service_completed_successfully
s3-init:
condition: service_completed_successfully
redis:
condition: service_started # Redis — кэш: реплики работают и без него
networks: [app, data, objects] # НЕТ ports: API доступен только через LB
read_only: true
tmpfs: [/tmp]
cap_drop: [ALL]
security_opt: ["no-new-privileges:true"]
restart: unless-stopped
stop_signal: SIGTERM
stop_grace_period: 15s # drain 3 с + завершение запросов в полёте (≤10 с)
services:
lb:
image: haproxy:3.0.5-alpine
volumes:
- ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
environment:
LB_SERVER_MAXCONN: ${LB_SERVER_MAXCONN:-10}
LB_QUEUE_TIMEOUT: ${LB_QUEUE_TIMEOUT:-2s}
ports:
- "127.0.0.1:${API_PORT:-8080}:8080" # публичный API
- "127.0.0.1:${API_TTL_PORT:-8081}:8081" # api-ttl (профиль ttl), тоже только через LB
- "127.0.0.1:${API_FAULT_PORT:-8082}:8082" # api-fault (профиль fault): только для теста компенсации
- "127.0.0.1:${LB_STATS_PORT:-8404}:8404" # статистика HAProxy (только чтение)
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8404/stats"]
interval: 5s
timeout: 2s
retries: 3
networks: [edge, app]
restart: unless-stopped
stop_grace_period: 5s
deploy:
resources:
limits: {cpus: "0.5", memory: 128M}
# One-shot: миграции применяются ОДИН раз до запуска реплик (не гонкой реплик).
# Повторный запуск (docker compose run --rm migrate) — no-op. Реплики не становятся ready,
# пока схема не содержит все известные им миграции.
migrate:
<<: *api-common
command: ["migrate"]
depends_on:
postgres:
condition: service_healthy
networks: [data]
restart: "no"
secrets: [database_url]
environment:
<<: *api-env
SESSION_CACHE: "off"
S3_ACCESS_KEY_ID_FILE: "" # migrate не работает с S3
S3_SECRET_ACCESS_KEY_FILE: ""
deploy:
resources:
limits: {cpus: "0.5", memory: 256M}
api:
<<: *api-common
deploy:
replicas: ${API_REPLICAS:-2}
resources:
limits: {cpus: "${API_CPUS:-1.0}", memory: "${API_MEMORY:-512M}"}
# Экземпляр с коротким TTL — только для теста истечения; доступен через LB на :8081.
api-ttl:
<<: *api-common
profiles: [ttl]
environment:
<<: *api-env
SESSION_TTL_SECONDS: "2"
deploy:
resources:
limits: {cpus: "0.5", memory: 256M}
# ТОЛЬКО для теста компенсации (уровень 4): процесс завершается сразу после S3 PUT, до COMMIT
# метаданных. Короткий grace period, чтобы очистка сработала за секунды. Доступен через LB :8082.
api-fault:
<<: *api-common
profiles: [fault]
environment:
<<: *api-env
FAULT_INJECT: crash_after_s3_put
UPLOAD_GRACE_SECONDS: "10"
UPLOAD_TIMEOUT_SECONDS: "5" # intent «брошен» не раньше max(grace, timeout+5) = 10 с
JANITOR_INTERVAL_SECONDS: "2"
deploy:
resources:
limits: {cpus: "0.5", memory: 256M}
# S3-совместимое хранилище: SeaweedFS (master+volume+filer+S3 в одном процессе).
# master/volume/filer (и их web-консоли) слушают только 127.0.0.1 внутри контейнера; наружу
# контейнера — только S3 API :9000, и только во внутренней сети objects. Порты на хост не публикуются.
s3:
image: chrislusf/seaweedfs:4.52
entrypoint: ["/usr/bin/weed"]
# Быстрая остановка: SIGINT + preStopSeconds=1 (иначе restart s3 занимает ~10 с впустую)
stop_signal: SIGINT
stop_grace_period: 5s
command:
- -logtostderr=true
- server
- -dir=/data
- -ip=127.0.0.1
- -ip.bind=127.0.0.1
- -s3
- -s3.port=9000
- -s3.ip.bind=0.0.0.0
- -s3.config=/run/secrets/s3_config
- -master.volumeSizeLimitMB=1024
- -master.electionTimeout=2s # единственный master: быстрее становится лидером после рестарта
- -volume.max=0
- -volume.preStopSeconds=1 # по умолчанию 10 с ожидания при остановке (рассчитано на кластер)
# Без лимитов weed буферизует все одновременные загрузки и при 10×10 МиБ был убит OOM (512M).
# С лимитами лишние загрузки ждут очереди внутри S3, а не роняют его (см. REPORT.md, эксперимент).
- -s3.concurrentFileUploadLimit=8
- -s3.concurrentUploadLimitMB=96
- -filer.concurrentUploadLimitMB=96
- -volume.concurrentUploadLimitMB=96
- -s3.cacheCapacityMB=32
- -master.telemetry=false # не отправлять статистику во внешний интернет
environment:
# Мягкий лимит кучи Go: GC держит weed ниже ~640 МиБ при лимите контейнера 1 ГиБ (без него
# куча после пика не отдаётся и под нагрузкой процесс убивает OOM).
GOMEMLIMIT: 640MiB
secrets: [s3_config]
volumes:
- s3data:/data
healthcheck:
# healthy = S3-шлюз жив, master — лидер И запись возможна. После рестарта SeaweedFS 4.52 ~15 с
# «прогревает» топологию (pulse 5 с × 3, в коде не настраивается): чтение уже работает, а запись
# ждёт. /dir/assign отдаёт fid только по окончании прогрева, поэтому хуки ждут именно его.
test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1:9000/healthz && wget -q -O /dev/null http://127.0.0.1:9333/cluster/healthz && wget -q -O - http://127.0.0.1:9333/dir/assign | grep -q fid"]
interval: 2s
timeout: 2s
retries: 30
start_period: 10s
networks: [objects]
restart: unless-stopped
deploy:
resources:
limits: {cpus: "1.0", memory: 1G}
# One-shot bootstrap S3: идемпотентно создаёт приватный bucket ключом администратора и проверяет,
# что анонимный доступ запрещён, а ключи API не могут создавать бакеты. Admin-ключи есть только здесь.
s3-init:
<<: *api-common # тот же образ (сборка из исходников), свои env/secrets/сеть
command: ["s3-bootstrap"]
environment:
S3_ENDPOINT: http://s3:9000
S3_REGION: ${S3_REGION:-us-east-1}
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_ADMIN_ACCESS_KEY_ID_FILE: /run/secrets/s3_admin_access_key_id
S3_ADMIN_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_admin_secret_access_key
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key
secrets: [s3_admin_access_key_id, s3_admin_secret_access_key, s3_access_key_id, s3_secret_access_key]
depends_on:
s3:
condition: service_healthy
networks: [objects]
restart: "no"
deploy:
resources:
limits: {cpus: "0.25", memory: 128M}
postgres:
image: postgres:16.10-alpine
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
POSTGRES_INITDB_ARGS: "--auth-host=scram-sha-256 --data-checksums"
command: ["postgres", "-c", "max_connections=${PG_MAX_CONNECTIONS:-100}"]
secrets: [postgres_password]
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger -h 127.0.0.1"]
interval: 2s
timeout: 3s
retries: 30
start_period: 10s
networks: [data]
shm_size: 256m
restart: unless-stopped
stop_grace_period: 30s
deploy:
resources:
limits: {cpus: "${PG_CPUS:-1.0}", memory: 1G}
# Redis — общий кэш сессий без persistence; источник истины сессий — PostgreSQL.
redis:
image: redis:7.4.2-alpine
command:
- sh
- -c
- |
umask 077
printf 'requirepass %s\n' "$$(cat /run/secrets/redis_password)" > /tmp/redis.conf
exec redis-server /tmp/redis.conf --save '' --appendonly no --maxmemory 64mb --maxmemory-policy allkeys-lru
user: redis
secrets: [redis_password]
healthcheck:
test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping | grep -q PONG"]
interval: 2s
timeout: 2s
retries: 15
networks: [data]
restart: unless-stopped
deploy:
resources:
limits: {cpus: "0.25", memory: 128M}
networks:
edge: {} # только LB: публикация портов на 127.0.0.1
app:
internal: true # LB ↔ API
data:
internal: true # API ↔ PostgreSQL/Redis
objects:
internal: true # API ↔ S3 (SeaweedFS); PostgreSQL/Redis отсюда недоступны
volumes:
pgdata: {}
s3data: {} # объекты вложений (persistent)
secrets:
postgres_password:
file: ./secrets/postgres_password
redis_password:
file: ./secrets/redis_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
s3_config: # identities SeaweedFS: admin и api (права только на bucket)
file: ./secrets/s3_config.json
s3_admin_access_key_id:
file: ./secrets/s3_admin_access_key_id
s3_admin_secret_access_key:
file: ./secrets/s3_admin_secret_access_key
s3_access_key_id:
file: ./secrets/s3_access_key_id
s3_secret_access_key:
file: ./secrets/s3_secret_access_key
+17
View File
@@ -0,0 +1,17 @@
# Расширения решения (обратно совместимые)
Обязательный контракт (`openapi.json`, `README.md`) не изменён. Дополнительно реализовано:
| Что | Где | Семантика |
| --- | --- | --- |
| Заголовок ответа `Idempotent-Replayed: true` | `POST /api/v1/chats/{chat_id}/messages` | Ответ 201 — повтор ранее сохранённого результата по тому же `Idempotency-Key` (тело и код совпадают с первым ответом). Клиент может игнорировать. |
| `GET /internal/stats` | только изнутри контейнера реплики (`127.0.0.1`); LB отвечает на `/internal/*` 404 в формате ошибок API | Диагностика для исследования: alias реплики, версия, счётчики запросов, кэша сессий и пула соединений psycopg. `python -m messenger stats` в контейнере. |
| `GET /internal/stats` (lab4): `memory.rss_kib`/`peak_rss_kib` (VmRSS/VmHWM), `uploads_in_flight`, счётчики `uploads_*`, `compensations`, `janitor_removed`; `?reset_peak=1` сбрасывает VmHWM | изнутри контейнера: `python -m messenger stats [--reset-peak]` | Измерение пика памяти в эксперименте с одновременными загрузками. |
| Ответ на `GET /api/v1/attachments/{id}/content`, если объект утрачен в S3 | API | `500 internal` «Содержимое вложения утрачено» (не маскируется под 404: метаданные есть, байтов нет); reconciler помечает такие вложения в `attachment_integrity`. Пока S3 недоступен — `503 unavailable`. |
| Заголовки ответа download | API | `Content-Type` из метаданных (проверен по содержимому), `Content-Length`, `ETag: "<sha256>"`, `X-Content-Type-Options: nosniff`, `Cache-Control: private, no-store`, `Content-Disposition: inline; filename*=UTF-8''…` (filename только для отображения). |
| Операционные команды (не HTTP) | `python -m messenger s3-bootstrap \| s3-check \| reconcile [--apply] [--verify-checksums] [--grace-seconds N]` | Идемпотентное создание приватного bucket admin-ключом (сервис `s3-init`), проверка приватности вне API, reconciler трека 2 (по умолчанию dry-run). |
| Ответы, созданные самим LB (502/503/504/404 для `/internal/*`) | HAProxy | Тело в формате ошибок API с `request_id` = `X-Request-Id` (случайный uuid). `X-Instance-Id` у них нет — контракт это допускает. |
Область ключа идемпотентности: пользователь + `POST` + `/api/v1/chats/{chat_id}/messages` + ключ. Других
идемпотентных endpoint в обязательном API нет, поэтому хранится тройка `(user_id, chat_id, key)`.
Срок хранения — `IDEMPOTENCY_TTL_SECONDS` (по умолчанию 86 400 с = 24 ч).
@@ -0,0 +1,9 @@
# 2026-11-05T21:39:24Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ sh -c for c in $(docker compose --env-file .env ps -q api); do docker inspect -f '{{.Name}} ReadonlyRootfs={{.HostConfig.ReadonlyRootfs}} Tmpfs={{json .HostConfig.Tmpfs}} Mounts={{range .Mounts}}{{.Type}}:{{.Destination}} {{end}}' $c; docker exec $c sh -c 'echo tmp: $(ls -A /tmp); touch /app/x 2>&1 | head -1'; done
/mtusi-lab4-api-1 ReadonlyRootfs=true Tmpfs={"/tmp":""} Mounts=bind:/run/secrets/cache_url bind:/run/secrets/database_url bind:/run/secrets/s3_access_key_id bind:/run/secrets/s3_secret_access_key
tmp: instance-id
touch: cannot touch '/app/x': Read-only file system
/mtusi-lab4-api-2 ReadonlyRootfs=true Tmpfs={"/tmp":""} Mounts=bind:/run/secrets/cache_url bind:/run/secrets/database_url bind:/run/secrets/s3_access_key_id bind:/run/secrets/s3_secret_access_key
tmp: instance-id
touch: cannot touch '/app/x': Read-only file system
exit=0
+6
View File
@@ -0,0 +1,6 @@
# 2026-11-05T21:20:46Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url http://127.0.0.1:8080
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 135, "failed_attempts": 0, "first_recovery_seconds": 5.545}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
exit=0
+6
View File
@@ -0,0 +1,6 @@
# 2026-11-05T21:21:10Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url http://127.0.0.1:8080
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 137, "failed_attempts": 0, "first_recovery_seconds": 5.235}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
exit=0
+40
View File
@@ -0,0 +1,40 @@
== 2026-11-05T21:20:48Z stop-one target=api-90af3d76 container=mtusi-lab4-api-1
api mtusi-lab4-api-1 status=running started=2026-11-05T21:19:55.122582674Z pid=24530
api mtusi-lab4-api-2 status=running started=2026-11-05T21:19:55.497019268Z pid=24594
api-ttl mtusi-lab4-api-ttl-1 status=running started=2026-11-05T21:19:54.837446008Z pid=24474
lb mtusi-lab4-lb-1 status=running started=2026-11-05T21:19:42.048718184Z pid=23688
migrate mtusi-lab4-migrate-1 status=exited started=2026-11-05T21:19:48.354406692Z pid=0
postgres mtusi-lab4-postgres-1 status=running started=2026-11-05T21:19:42.627650356Z pid=23871
redis mtusi-lab4-redis-1 status=running started=2026-11-05T21:19:41.796795921Z pid=23626
s3 mtusi-lab4-s3-1 status=running started=2026-11-05T21:19:42.425861715Z pid=23812
s3-init mtusi-lab4-s3-init-1 status=exited started=2026-11-05T21:19:52.626680253Z pid=0
== 2026-11-05T21:20:53Z after stop
api mtusi-lab4-api-1 status=exited started=2026-11-05T21:19:55.122582674Z pid=0
api mtusi-lab4-api-2 status=running started=2026-11-05T21:19:55.497019268Z pid=24594
api-ttl mtusi-lab4-api-ttl-1 status=running started=2026-11-05T21:19:54.837446008Z pid=24474
lb mtusi-lab4-lb-1 status=running started=2026-11-05T21:19:42.048718184Z pid=23688
migrate mtusi-lab4-migrate-1 status=exited started=2026-11-05T21:19:48.354406692Z pid=0
postgres mtusi-lab4-postgres-1 status=running started=2026-11-05T21:19:42.627650356Z pid=23871
redis mtusi-lab4-redis-1 status=running started=2026-11-05T21:19:41.796795921Z pid=23626
s3 mtusi-lab4-s3-1 status=running started=2026-11-05T21:19:42.425861715Z pid=23812
s3-init mtusi-lab4-s3-init-1 status=exited started=2026-11-05T21:19:52.626680253Z pid=0
== 2026-11-05T21:21:12Z stop-one target=api-21d825d2 container=mtusi-lab4-api-1
api mtusi-lab4-api-1 status=running started=2026-11-05T21:21:03.87668756Z pid=29660
api mtusi-lab4-api-2 status=running started=2026-11-05T21:19:55.497019268Z pid=24594
api-ttl mtusi-lab4-api-ttl-1 status=running started=2026-11-05T21:19:54.837446008Z pid=24474
lb mtusi-lab4-lb-1 status=running started=2026-11-05T21:19:42.048718184Z pid=23688
migrate mtusi-lab4-migrate-1 status=exited started=2026-11-05T21:19:48.354406692Z pid=0
postgres mtusi-lab4-postgres-1 status=running started=2026-11-05T21:19:42.627650356Z pid=23871
redis mtusi-lab4-redis-1 status=running started=2026-11-05T21:19:41.796795921Z pid=23626
s3 mtusi-lab4-s3-1 status=running started=2026-11-05T21:19:42.425861715Z pid=23812
s3-init mtusi-lab4-s3-init-1 status=exited started=2026-11-05T21:19:52.626680253Z pid=0
== 2026-11-05T21:21:17Z after stop
api mtusi-lab4-api-1 status=exited started=2026-11-05T21:21:03.87668756Z pid=0
api mtusi-lab4-api-2 status=running started=2026-11-05T21:19:55.497019268Z pid=24594
api-ttl mtusi-lab4-api-ttl-1 status=running started=2026-11-05T21:19:54.837446008Z pid=24474
lb mtusi-lab4-lb-1 status=running started=2026-11-05T21:19:42.048718184Z pid=23688
migrate mtusi-lab4-migrate-1 status=exited started=2026-11-05T21:19:48.354406692Z pid=0
postgres mtusi-lab4-postgres-1 status=running started=2026-11-05T21:19:42.627650356Z pid=23871
redis mtusi-lab4-redis-1 status=running started=2026-11-05T21:19:41.796795921Z pid=23626
s3 mtusi-lab4-s3-1 status=running started=2026-11-05T21:19:42.425861715Z pid=23812
s3-init mtusi-lab4-s3-init-1 status=exited started=2026-11-05T21:19:52.626680253Z pid=0
+9
View File
@@ -0,0 +1,9 @@
# 2026-11-05T21:20:06Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ sh -c for i in 1 2 3 4 5 6; do curl -s -o /dev/null -D - http://127.0.0.1:8080/health/live | grep -i x-instance-id; done
x-instance-id: api-8b81f8b6
x-instance-id: api-90af3d76
x-instance-id: api-8b81f8b6
x-instance-id: api-90af3d76
x-instance-id: api-8b81f8b6
x-instance-id: api-90af3d76
exit=0
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 4,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.033,
"concurrency": 4,
"successful_requests": 7542,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 251.122,
"successful_latency_ms": {
"p50": 13.99,
"p95": 30.571,
"p99": 47.031
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+20
View File
@@ -0,0 +1,20 @@
# 2026-11-05T21:29:56Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 tests/load.py --base-url http://127.0.0.1:8080 --duration 30 --concurrency 4 --output evidence/load.json
{
"lab": 4,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.033,
"concurrency": 4,
"successful_requests": 7542,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 251.122,
"successful_latency_ms": {
"p50": 13.99,
"p95": 30.571,
"p99": 47.031
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
exit=0
+5
View File
@@ -0,0 +1,5 @@
# 2026-11-05T21:20:06Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
exit=0
@@ -0,0 +1,6 @@
# 2026-11-05T21:29:55Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ dc run --rm --no-deps migrate
Container mtusi-lab4-migrate-run-dcb827d5b479 Creating
Container mtusi-lab4-migrate-run-dcb827d5b479 Created
{"applied": []}
exit=0
+18
View File
@@ -0,0 +1,18 @@
# 2026-11-05T21:39:39Z migrations: одна запись на версию (PK), applied_at — момент первого применения на пустом volume
$ psql: SELECT version, left(checksum,12), applied_at FROM schema_migrations; docker compose logs migrate (повторные запуски — no-op)
version | checksum | applied_at
--------------------------------+--------------+-------------------------------
0001_init | 64c1576d88cc | 2026-11-05 21:19:49.06371+00
0002_cache_invalidation_outbox | fcebf1c9345a | 2026-11-05 21:19:49.069526+00
0003_idempotency_keys | e2564612d780 | 2026-11-05 21:19:49.074626+00
0004_attachments | 52090521af1b | 2026-11-05 21:19:49.088545+00
(4 rows)
{"ts": "2026-11-05T21:19:49Z", "level": "info", "logger": "messenger.db", "msg": "migration applied", "version": "0001_init"}
{"ts": "2026-11-05T21:19:49Z", "level": "info", "logger": "messenger.db", "msg": "migration applied", "version": "0002_cache_invalidation_outbox"}
{"ts": "2026-11-05T21:19:49Z", "level": "info", "logger": "messenger.db", "msg": "migration applied", "version": "0003_idempotency_keys"}
{"ts": "2026-11-05T21:19:49Z", "level": "info", "logger": "messenger.db", "msg": "migration applied", "version": "0004_attachments"}
{"applied": ["0001_init", "0002_cache_invalidation_outbox", "0003_idempotency_keys", "0004_attachments"]}
{"applied": []}
{"applied": []}
exit=0
+5
View File
@@ -0,0 +1,5 @@
# 2026-11-05T21:21:34Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
exit=0
+285
View File
@@ -0,0 +1,285 @@
{
"method": "Трек 2: стоимость обхода reconciler в зависимости от числа объектов.",
"prefix": "bench-2c1c251b/",
"runs": [
{
"n_objects": 1000,
"object_bytes": 4096,
"seed_seconds": 14.6,
"dry_run": {
"wall_seconds_incl_exec": 0.82,
"exit": 0,
"scanned": {
"s3_objects": 1000,
"db_attachments": 1000,
"upload_intents": 0,
"multipart_uploads": 0
},
"counts": {
"ok": 1000
},
"actions": {},
"cost": {
"s3_list_seconds": 0.0733,
"db_snapshot_seconds": 0.034,
"classify_seconds": 0.0012,
"apply_seconds": 0.0,
"total_seconds": 0.1109,
"s3_requests_total": 2,
"s3_list_requests": 2,
"peak_rss_kib": 60668
}
},
"dry_run_verify_checksums": {
"wall_seconds_incl_exec": 3.32,
"exit": 0,
"scanned": {
"s3_objects": 1000,
"db_attachments": 1000,
"upload_intents": 0,
"multipart_uploads": 0
},
"counts": {
"ok": 1000
},
"actions": {},
"cost": {
"s3_list_seconds": 0.082,
"db_snapshot_seconds": 0.0499,
"classify_seconds": 2.4282,
"apply_seconds": 0.0,
"total_seconds": 2.5628,
"s3_requests_total": 1002,
"s3_list_requests": 2,
"peak_rss_kib": 60380
}
},
"apply_delete_orphans": {
"wall_seconds_incl_exec": 6.19,
"exit": 0,
"scanned": {
"s3_objects": 1000,
"db_attachments": 0,
"upload_intents": 0,
"multipart_uploads": 0
},
"counts": {
"orphan": 1000
},
"actions": {
"deleted_orphan_object": 1000
},
"cost": {
"s3_list_seconds": 0.0812,
"db_snapshot_seconds": 0.0039,
"classify_seconds": 0.0007,
"apply_seconds": 5.4294,
"total_seconds": 5.5181,
"s3_requests_total": 2002,
"s3_list_requests": 2,
"peak_rss_kib": 60332
}
},
"after_apply": {
"wall_seconds_incl_exec": 0.85,
"exit": 0,
"scanned": {
"s3_objects": 0,
"db_attachments": 0,
"upload_intents": 0,
"multipart_uploads": 0
},
"counts": {},
"actions": {},
"cost": {
"s3_list_seconds": 0.0518,
"db_snapshot_seconds": 0.004,
"classify_seconds": 0.0,
"apply_seconds": 0.0,
"total_seconds": 0.0581,
"s3_requests_total": 2,
"s3_list_requests": 2,
"peak_rss_kib": 60436
}
}
},
{
"n_objects": 5000,
"object_bytes": 4096,
"seed_seconds": 66.0,
"dry_run": {
"wall_seconds_incl_exec": 1.24,
"exit": 0,
"scanned": {
"s3_objects": 5000,
"db_attachments": 5000,
"upload_intents": 0,
"multipart_uploads": 0
},
"counts": {
"ok": 5000
},
"actions": {},
"cost": {
"s3_list_seconds": 0.2253,
"db_snapshot_seconds": 0.1978,
"classify_seconds": 0.0076,
"apply_seconds": 0.0,
"total_seconds": 0.4339,
"s3_requests_total": 6,
"s3_list_requests": 6,
"peak_rss_kib": 64044
}
},
"dry_run_verify_checksums": {
"wall_seconds_incl_exec": 14.39,
"exit": 0,
"scanned": {
"s3_objects": 5000,
"db_attachments": 5000,
"upload_intents": 0,
"multipart_uploads": 0
},
"counts": {
"ok": 5000
},
"actions": {},
"cost": {
"s3_list_seconds": 0.1946,
"db_snapshot_seconds": 0.2017,
"classify_seconds": 13.1799,
"apply_seconds": 0.0,
"total_seconds": 13.5816,
"s3_requests_total": 5006,
"s3_list_requests": 6,
"peak_rss_kib": 65064
}
},
"apply_delete_orphans": {
"wall_seconds_incl_exec": 29.46,
"exit": 0,
"scanned": {
"s3_objects": 5000,
"db_attachments": 0,
"upload_intents": 0,
"multipart_uploads": 0
},
"counts": {
"orphan": 5000
},
"actions": {
"deleted_orphan_object": 5000
},
"cost": {
"s3_list_seconds": 0.2221,
"db_snapshot_seconds": 0.0065,
"classify_seconds": 0.0122,
"apply_seconds": 28.3565,
"total_seconds": 28.6006,
"s3_requests_total": 10006,
"s3_list_requests": 6,
"peak_rss_kib": 61828
}
},
"after_apply": {
"wall_seconds_incl_exec": 0.97,
"exit": 0,
"scanned": {
"s3_objects": 0,
"db_attachments": 0,
"upload_intents": 0,
"multipart_uploads": 0
},
"counts": {},
"actions": {},
"cost": {
"s3_list_seconds": 0.0578,
"db_snapshot_seconds": 0.0055,
"classify_seconds": 0.0,
"apply_seconds": 0.0,
"total_seconds": 0.066,
"s3_requests_total": 2,
"s3_list_requests": 2,
"peak_rss_kib": 60524
}
}
},
{
"n_objects": 20000,
"object_bytes": 4096,
"seed_seconds": 260.7,
"dry_run": {
"wall_seconds_incl_exec": 2.15,
"exit": 0,
"scanned": {
"s3_objects": 20000,
"db_attachments": 20000,
"upload_intents": 0,
"multipart_uploads": 0
},
"counts": {
"ok": 20000
},
"actions": {},
"cost": {
"s3_list_seconds": 0.756,
"db_snapshot_seconds": 0.6431,
"classify_seconds": 0.0413,
"apply_seconds": 0.0,
"total_seconds": 1.4466,
"s3_requests_total": 21,
"s3_list_requests": 21,
"peak_rss_kib": 82828
}
},
"apply_delete_orphans": {
"wall_seconds_incl_exec": 105.94,
"exit": 0,
"scanned": {
"s3_objects": 20000,
"db_attachments": 0,
"upload_intents": 0,
"multipart_uploads": 0
},
"counts": {
"orphan": 20000
},
"actions": {
"deleted_orphan_object": 20000
},
"cost": {
"s3_list_seconds": 0.6912,
"db_snapshot_seconds": 0.0068,
"classify_seconds": 0.0144,
"apply_seconds": 104.3966,
"total_seconds": 105.1177,
"s3_requests_total": 40021,
"s3_list_requests": 21,
"peak_rss_kib": 70484
}
},
"after_apply": {
"wall_seconds_incl_exec": 0.87,
"exit": 0,
"scanned": {
"s3_objects": 0,
"db_attachments": 0,
"upload_intents": 0,
"multipart_uploads": 0
},
"counts": {},
"actions": {},
"cost": {
"s3_list_seconds": 0.0635,
"db_snapshot_seconds": 0.0049,
"classify_seconds": 0.0,
"apply_seconds": 0.0,
"total_seconds": 0.0706,
"s3_requests_total": 2,
"s3_list_requests": 2,
"peak_rss_kib": 60336
}
}
}
]
}
@@ -0,0 +1,6 @@
# 2026-11-05T21:30:50Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 research/reconcile_cost.py --sizes 1000,5000,20000 --output evidence/reconcile-cost.json
N=1000 dry-run 0.11s (2 S3 req, rss 60668 KiB); apply {'deleted_orphan_object': 1000}; after {}
N=5000 dry-run 0.43s (6 S3 req, rss 64044 KiB); apply {'deleted_orphan_object': 5000}; after {}
N=20000 dry-run 1.45s (21 S3 req, rss 82828 KiB); apply {'deleted_orphan_object': 20000}; after {}
exit=0
@@ -0,0 +1,48 @@
# 2026-11-05T21:29:54Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ sh -c docker compose --env-file .env exec -T api python -m messenger reconcile --samples 5; echo reconcile_exit=$?
{
"mode": "dry-run",
"bucket": "messenger-attachments",
"prefix": "attachments/",
"grace_seconds": 900.0,
"intent_grace_seconds": 900.0,
"verify_checksums": false,
"scanned": {
"s3_objects": 958,
"db_attachments": 958,
"upload_intents": 0,
"multipart_uploads": 0
},
"counts": {
"checksum_flag_kept_unverified": 1,
"ok": 956,
"size_mismatch": 1
},
"actions": {},
"actionable_found": {},
"samples": {
"checksum_flag_kept_unverified": [
"79ca7157-d066-4e6e-b0e7-2690cd93a757"
],
"size_mismatch": [
{
"id": "5d154291-3dff-4686-9403-774446d4b3c9",
"db": 1088,
"s3": 1081
}
]
},
"errors": [],
"cost": {
"s3_list_seconds": 0.073,
"db_snapshot_seconds": 0.0276,
"classify_seconds": 0.0013,
"apply_seconds": 0.0,
"total_seconds": 0.1048,
"s3_requests_total": 2,
"s3_list_requests": 2,
"peak_rss_kib": 60332
}
}
reconcile_exit=0
exit=0
+26
View File
@@ -0,0 +1,26 @@
== 2026-11-05T21:21:36Z before restart
api mtusi-lab4-api-1 status=running started=2026-11-05T21:21:28.042188657Z pid=31540
api mtusi-lab4-api-2 status=running started=2026-11-05T21:19:55.497019268Z pid=24594
api-ttl mtusi-lab4-api-ttl-1 status=running started=2026-11-05T21:19:54.837446008Z pid=24474
lb mtusi-lab4-lb-1 status=running started=2026-11-05T21:19:42.048718184Z pid=23688
migrate mtusi-lab4-migrate-1 status=exited started=2026-11-05T21:19:48.354406692Z pid=0
postgres mtusi-lab4-postgres-1 status=running started=2026-11-05T21:19:42.627650356Z pid=23871
redis mtusi-lab4-redis-1 status=running started=2026-11-05T21:19:41.796795921Z pid=23626
s3 mtusi-lab4-s3-1 status=running started=2026-11-05T21:19:42.425861715Z pid=23812
s3-init mtusi-lab4-s3-init-1 status=exited started=2026-11-05T21:19:52.626680253Z pid=0
volume mtusi-lab3_pgdata
volume mtusi-lab4_pgdata
volume mtusi-lab4_s3data
== 2026-11-05T21:22:12Z after restart
api mtusi-lab4-api-1 status=running started=2026-11-05T21:22:08.637200585Z pid=2052
api mtusi-lab4-api-2 status=running started=2026-11-05T21:22:08.877452831Z pid=2107
api-ttl mtusi-lab4-api-ttl-1 status=running started=2026-11-05T21:22:11.766742969Z pid=2486
lb mtusi-lab4-lb-1 status=running started=2026-11-05T21:22:12.200962497Z pid=2568
migrate mtusi-lab4-migrate-1 status=exited started=2026-11-05T21:22:10.080276947Z pid=0
postgres mtusi-lab4-postgres-1 status=running started=2026-11-05T21:21:45.716232446Z pid=718
redis mtusi-lab4-redis-1 status=running started=2026-11-05T21:21:45.674233468Z pid=678
s3 mtusi-lab4-s3-1 status=running started=2026-11-05T21:21:46.716068372Z pid=852
s3-init mtusi-lab4-s3-init-1 status=exited started=2026-11-05T21:22:09.923934091Z pid=0
volume mtusi-lab3_pgdata
volume mtusi-lab4_pgdata
volume mtusi-lab4_s3data
+5
View File
@@ -0,0 +1,5 @@
# 2026-11-05T21:21:03Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ ./scripts/start-replicas.sh
api mtusi-lab4-api-1 status=running started=2026-11-05T21:21:03.87668756Z pid=29660
api mtusi-lab4-api-2 status=running started=2026-11-05T21:19:55.497019268Z pid=24594
exit=0
+5
View File
@@ -0,0 +1,5 @@
# 2026-11-05T21:21:27Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ ./scripts/start-replicas.sh
api mtusi-lab4-api-1 status=running started=2026-11-05T21:21:28.042188657Z pid=31540
api mtusi-lab4-api-2 status=running started=2026-11-05T21:19:55.497019268Z pid=24594
exit=0
@@ -0,0 +1,6 @@
# 2026-11-05T21:20:03Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ dc run --rm --no-deps s3-init
Container mtusi-lab4-s3-init-run-291a141a1630 Creating
Container mtusi-lab4-s3-init-run-291a141a1630 Created
{"bucket": "messenger-attachments", "created": false, "checks": {"anonymous ListObjects": ["403", 403, true], "anonymous GetObject": ["403", 403, true], "anonymous PutObject": ["403", 403, true], "anonymous ListBuckets": ["403", 403, true], "api ListObjects own bucket": ["allowed", "allowed", true], "api CreateBucket": ["AccessDenied", "AccessDenied", true]}}
exit=0
+4
View File
@@ -0,0 +1,4 @@
# 2026-11-05T21:20:02Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ dc logs --no-log-prefix s3-init
{"bucket": "messenger-attachments", "created": true, "checks": {"anonymous ListObjects": ["403", 403, true], "anonymous GetObject": ["403", 403, true], "anonymous PutObject": ["403", 403, true], "anonymous ListBuckets": ["403", 403, true], "api ListObjects own bucket": ["allowed", "allowed", true], "api CreateBucket": ["AccessDenied", "AccessDenied", true]}}
exit=0
+9
View File
@@ -0,0 +1,9 @@
# 2026-11-05T21:20:05Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ dc exec -T api python -m messenger s3-check
PASS anonymous ListObjects expected=403 got=403
PASS anonymous GetObject expected=403 got=403
PASS anonymous PutObject expected=403 got=403
PASS anonymous ListBuckets expected=403 got=403
PASS api ListObjects own bucket expected=allowed got=allowed
PASS api CreateBucket expected=AccessDenied got=AccessDenied
exit=0
+4
View File
@@ -0,0 +1,4 @@
# 2026-11-05T21:20:06Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 tests/smoke.py --base-url http://127.0.0.1:8080
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
exit=0
+32
View File
@@ -0,0 +1,32 @@
# 2026-11-05T21:20:01Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
docker 29.9.2
Docker Compose version v5.6.1
CONTAINER REPOSITORY TAG PLATFORM IMAGE ID SIZE CREATED
mtusi-lab4-api-1 mtusi-lab4-api local linux/amd64 57e267698b3f 2.63GB 25 seconds ago
mtusi-lab4-api-2 mtusi-lab4-api local linux/amd64 57e267698b3f 2.63GB 25 seconds ago
mtusi-lab4-api-ttl-1 mtusi-lab4-api local linux/amd64 57e267698b3f 2.63GB 25 seconds ago
mtusi-lab4-lb-1 mtusi-local/haproxy 3.0 linux/amd64 c93e4aeed30e 42MB 2 days ago
mtusi-lab4-migrate-1 mtusi-lab4-api local linux/amd64 57e267698b3f 2.63GB 25 seconds ago
mtusi-lab4-postgres-1 mtusi-local/postgres 16 linux/amd64 2f004dbde9b5 337MB 2 days ago
mtusi-lab4-redis-1 mtusi-local/redis 7 linux/amd64 01c11b3e9bd0 37.1MB 2 days ago
mtusi-lab4-s3-1 mtusi-local/seaweedfs 4.52 linux/amd64 97add7389e30 242MB About an hour ago
mtusi-lab4-s3-init-1 mtusi-lab4-api local linux/amd64 57e267698b3f 2.63GB 25 seconds ago
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab4-api-1 mtusi-lab4-api:local "python -m messenger…" api 21 seconds ago Up 6 seconds (healthy) 8080/tcp
mtusi-lab4-api-2 mtusi-lab4-api:local "python -m messenger…" api 21 seconds ago Up 6 seconds (healthy) 8080/tcp
mtusi-lab4-api-ttl-1 mtusi-lab4-api:local "python -m messenger…" api-ttl 21 seconds ago Up 7 seconds (healthy) 8080/tcp
mtusi-lab4-lb-1 mtusi-local/haproxy:3.0 "haproxy -W -db -f /…" lb 21 seconds ago Up 20 seconds (healthy) 127.0.0.1:8080-8082->8080-8082/tcp, 127.0.0.1:8404->8404/tcp
mtusi-lab4-migrate-1 mtusi-lab4-api:local "python -m messenger…" migrate 21 seconds ago Exited (0) 12 seconds ago
mtusi-lab4-postgres-1 mtusi-local/postgres:16 "docker-entrypoint.s…" postgres 21 seconds ago Up 19 seconds (healthy)
mtusi-lab4-redis-1 mtusi-local/redis:7 "sh -c 'umask 077\npr…" redis 21 seconds ago Up 20 seconds (healthy)
mtusi-lab4-s3-1 mtusi-local/seaweedfs:4.52 "/usr/bin/weed -logt…" s3 21 seconds ago Up 19 seconds (healthy)
mtusi-lab4-s3-init-1 mtusi-lab4-api:local "python -m messenger…" s3-init 21 seconds ago Exited (0) 7 seconds ago
api mtusi-lab4-api-1 status=running started=2026-11-05T21:19:55.122582674Z pid=24530
api mtusi-lab4-api-2 status=running started=2026-11-05T21:19:55.497019268Z pid=24594
api-ttl mtusi-lab4-api-ttl-1 status=running started=2026-11-05T21:19:54.837446008Z pid=24474
lb mtusi-lab4-lb-1 status=running started=2026-11-05T21:19:42.048718184Z pid=23688
migrate mtusi-lab4-migrate-1 status=exited started=2026-11-05T21:19:48.354406692Z pid=0
postgres mtusi-lab4-postgres-1 status=running started=2026-11-05T21:19:42.627650356Z pid=23871
redis mtusi-lab4-redis-1 status=running started=2026-11-05T21:19:41.796795921Z pid=23626
s3 mtusi-lab4-s3-1 status=running started=2026-11-05T21:19:42.425861715Z pid=23812
s3-init mtusi-lab4-s3-init-1 status=exited started=2026-11-05T21:19:52.626680253Z pid=0
+23
View File
@@ -0,0 +1,23 @@
# 2026-11-05T21:20:14Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 student-tests/test_api.py
## API, auth, validation, ACL, transactions (http://127.0.0.1:8080)
PASS password stored only as scrypt KDF hash; User has no secret fields 0.97s
PASS wrong password and unknown user: identical 401 + Basic challenge 1.01s
PASS malformed Basic / Bearer on /auth/sessions / body on login 0.01s
PASS password with ':' and non-ASCII UTF-8 works (RFC 7617) 0.68s
PASS opaque 256-bit token, unique per login, DB stores only SHA-256 1.04s
PASS only Bearer accepted; Basic and X-User-Id never authenticate 0.02s
PASS logout revokes only the current session; repeat -> 401 1.13s
PASS strict JSON validation -> 400 0.04s
PASS message text: 4000 code points OK, 4001 / whitespace / sender_id -> 400 0.04s
PASS SQL is parameterized: injection payloads stored verbatim 0.02s
PASS ACL: outsider gets 404 everywhere (even for invalid body) 0.04s
PASS create chat validation: duplicates, caller missing, unknown member 0.01s
PASS compound create-chat rolls back on FK failure (no orphan chat) 0.98s chats before=4, failed insert left 0 rows
PASS registration race: 20 parallel same username -> exactly one 201 3.67s 201x1, 409x19, rows=1
PASS keyset pagination: 120 msgs, varying limit, no gaps/duplicates 1.20s 4 pages
PASS chat list: only own chats, ordered, cursor bound to user 0.76s
PASS read-after-write: confirmed message visible to next read 0.01s
PASS unknown route 404 / wrong method 405 in error format 0.01s
summary: 18 passed, 0 failed
exit=0
@@ -0,0 +1,18 @@
# 2026-11-05T21:20:09Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 student-tests/test_attachments.py
## attachments (http://127.0.0.1:8080)
PASS valid PNG and JPEG: 201 ready, byte-exact download by other member 0.12s
PASS exactly-near limit (~10 MiB) accepted, Content-Length > limit -> 413 0.56s 10.00 MiB accepted
PASS oversize rejected BEFORE body is read (early 413, socket) 0.00s HTTP/1.1 413 Content Too Large in 0.004s, 50 MiB never sent
PASS pixel limit: 8000x6000 header -> 413 without decoding 0.05s 0.051s
PASS decompression bomb: IDAT inflates beyond declared size -> 415 0.32s 65295-byte file claiming 64 MiB raw, rejected in 0.022s
PASS corrupted images -> 415 (truncated, bad CRC, no EOI, garbage, empty) 0.21s 9 variants
PASS MIME spoofing by Content-Type/filename -> 415 0.07s
PASS dangerous/invalid filenames -> 400; filename never becomes a path 0.08s
PASS missing/invalid Content-Length -> 400 (chunked upload is not accepted) 0.01s HTTP/1.1 400 Bad Request
PASS ACL: outsider gets 404 for upload/metadata/content; anonymous 401 0.53s outsider 10 MiB upload rejected in 0.44s
PASS variants: original OK, thumbnail absent in lab4 -> 404, unknown -> 400 0.03s
PASS message: foreign/unknown attachment_id -> 404, file of other chat -> 404, limits -> 400 0.10s
PASS idempotency includes attachment_ids (replay same, conflict on change) 0.06s
summary: 13 passed, 0 failed
exit=0
@@ -0,0 +1,16 @@
# 2026-11-05T21:20:43Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ make test-cache-race
docker compose --env-file .env run --rm --no-deps -T -v "/home/claude/work4/mtusi2026lab4/student-tests:/app/student-tests:ro" --entrypoint python api student-tests/test_cache_race.py
Container mtusi-lab4-api-run-3d1f6cdcdb56 Creating
Container mtusi-lab4-api-run-3d1f6cdcdb56 Created
PASS read-through put makes entry readable
PASS entry TTL capped by SESSION_CACHE_TTL_SECONDS pttl=59999ms
PASS invalidate removes entry
PASS late put after logout is refused by tombstone
PASS tombstone outlives any cache entry pttl=74997ms
PASS entry never outlives session expiry pttl=1199ms
PASS expired session not served from cache
cache unavailable; falling back to PostgreSQL
PASS degraded mode: cache is not read until outbox drained
summary: all passed
exit=0
+8
View File
@@ -0,0 +1,8 @@
# 2026-11-05T21:20:32Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 student-tests/test_expiry.py
## session expiry, SESSION_TTL_SECONDS=2 (http://127.0.0.1:8081)
PASS expires_at = now + SESSION_TTL_SECONDS 1.10s remaining 2.00s
PASS token valid before expiry, 401 Bearer after (cache warmed) 4.38s
PASS re-login after expiry issues a new valid session 5.43s
summary: 3 passed, 0 failed
exit=0
+7
View File
@@ -0,0 +1,7 @@
# 2026-11-05T21:23:22Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 student-tests/test_failures.py
## dependency failures (http://127.0.0.1:8080)
PASS Redis down: API bypasses cache via PostgreSQL, no anonymous trust 6.65s fallback latency 0.018s; outbox rows during outage=1, drained after recovery
PASS PostgreSQL down: bounded 503 in error format; anonymous still 401 15.23s latency(s)={'ready': 1.5, 'post_message': 2.01, 'history': 2.01, 'login': 2.01, 'register': 2.01}; ready again in 3.0s
summary: 2 passed, 0 failed
exit=0
@@ -0,0 +1,14 @@
# 2026-11-05T21:20:27Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 student-tests/test_idempotency.py
## idempotency across replicas (http://127.0.0.1:8080)
PASS sequential replays: same 201 + same Message from different replicas 0.32s replicas=2, rows=1
PASS 30 concurrent POSTs, same key + body, via LB -> exactly one message 0.73s per-replica responses {'api-90af3d76': 13, 'api-8b81f8b6': 17}, rows=1
PASS concurrent same key, two different bodies -> one message, others 201-same or 409 0.89s 201x10, 409x10
PASS after commit: different body -> 409; reordered/whitespace JSON -> replay 0.02s
PASS scope: user + chat + key (same key elsewhere is independent) 0.03s
PASS key format: missing/empty/129 chars/invalid -> 400; 128 chars ok 0.04s
PASS failed attempt does not claim the key (400/404 not recorded) 0.02s
PASS replay re-checks session and access 0.32s
PASS key older than IDEMPOTENCY_TTL_SECONDS is reusable (24 h window) 0.62s
summary: 9 passed, 0 failed
exit=0
+12
View File
@@ -0,0 +1,12 @@
# 2026-11-05T21:24:17Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 student-tests/test_reconcile.py
## reconciler (track 2, grace=60.0s, http://127.0.0.1:8080)
PASS inject faults: DB side and S3 side (old) + fresh/used controls 85.77s 14 fault/control items
PASS dry-run detects every class and changes nothing (exit 2) 13.79s scanned {'s3_objects': 113, 'db_attachments': 111, 'upload_intents': 3, 'multipart_uploads': 0}, cost 7.202s / 109 S3 req
PASS apply fixes only safe classes; fresh and used items untouched 19.42s actions {'deleted_orphan_object': 2, 'deleted_stale_upload_object': 2, 'removed_stale_intent': 2, 'deleted_lost_metadata': 1, 'flagged_checksum_mismatch': 1, 'flagged_size_mismatch': 1, 'flagged_missing_object': 1}
PASS fresh items are fixed only after they outlive grace; live intent still protected 37.14s fresh items aged 70s > grace; intent younger than UPLOAD_TIMEOUT+5 kept
PASS second run is idempotent: nothing actionable, no repeated actions 21.29s still reported (flagged, not actionable): {'checksum_mismatch': 1, 'missing_referenced': 1, 'size_mismatch': 1}
PASS restored object (from backup) clears the flag; download works again 4.53s
PASS concurrent uploads+messages during reconcile --apply (grace 0): nothing lost 20.25s 849 uploads, 6 reconcile --apply runs, 0 lost
summary: 7 passed, 0 failed
exit=0
@@ -0,0 +1,9 @@
# 2026-11-05T21:22:13Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 student-tests/test_storage_failures.py
## object storage failures (http://127.0.0.1:8080)
PASS bucket is private outside API: anonymous GET/LIST/PUT denied, API key limited 3.03s anon GET 403; s3-check 6/6 PASS
PASS S3 down: upload/download 503 fast, text messages and readiness keep working 28.72s 503 in 0.01s/0.01s; after start: reads 3.6s, writes 22.8s
PASS interrupted upload: no object and no intent left behind 7.76s objects 17, intents 1 — unchanged
PASS crash between S3 PUT and DB COMMIT: intent recorded, janitor removes object after grace 28.70s orphan attachments/91a4ecaa… removed 15.0s after crash (grace 10 s)
summary: 4 passed, 0 failed
exit=0
+169
View File
@@ -0,0 +1,169 @@
{
"hypothesis": "peak RSS grows by O(N*chunk), not O(N*file)",
"file_mib": 9.93,
"limits": {
"UPLOAD_CONCURRENCY_per_replica": 16,
"api_memory_limit": "256M",
"s3_memory_limit": "1G",
"s3_concurrentUploadLimitMB": 96
},
"runs": [
{
"concurrency": 1,
"client_rate_bytes_per_s": "unlimited",
"file_bytes": 10417403,
"ok_201": 1,
"statuses": [
"201"
],
"wall_seconds": 0.26,
"upload_seconds_max": 0.26,
"replicas": {
"25311601e8f2": {
"rss_before_kib": 62356,
"peak_kib": 62356,
"peak_delta_mib": 0.0
},
"75db68ff6ae1": {
"rss_before_kib": 62564,
"peak_kib": 62564,
"peak_delta_mib": 0.0
}
},
"max_peak_delta_mib": 0.0,
"s3_anon_peak_mib": 172.0,
"if_buffered_mib_per_replica": 5.0
},
{
"concurrency": 10,
"client_rate_bytes_per_s": "unlimited",
"file_bytes": 10417403,
"ok_201": 10,
"statuses": [
"201"
],
"wall_seconds": 2.02,
"upload_seconds_max": 2.01,
"replicas": {
"25311601e8f2": {
"rss_before_kib": 62356,
"peak_kib": 63720,
"peak_delta_mib": 1.3
},
"75db68ff6ae1": {
"rss_before_kib": 62564,
"peak_kib": 63164,
"peak_delta_mib": 0.6
}
},
"max_peak_delta_mib": 1.3,
"s3_anon_peak_mib": 491.6,
"if_buffered_mib_per_replica": 49.7
},
{
"concurrency": 20,
"client_rate_bytes_per_s": "unlimited",
"file_bytes": 10417403,
"ok_201": 20,
"statuses": [
"201"
],
"wall_seconds": 3.43,
"upload_seconds_max": 3.401,
"replicas": {
"25311601e8f2": {
"rss_before_kib": 62632,
"peak_kib": 66060,
"peak_delta_mib": 3.3
},
"75db68ff6ae1": {
"rss_before_kib": 62692,
"peak_kib": 65976,
"peak_delta_mib": 3.2
}
},
"max_peak_delta_mib": 3.3,
"s3_anon_peak_mib": 492.5,
"if_buffered_mib_per_replica": 99.3
},
{
"concurrency": 32,
"client_rate_bytes_per_s": "unlimited",
"file_bytes": 10417403,
"ok_201": 25,
"statuses": [
"201",
"503"
],
"wall_seconds": 4.62,
"upload_seconds_max": 4.591,
"replicas": {
"25311601e8f2": {
"rss_before_kib": 63956,
"peak_kib": 66068,
"peak_delta_mib": 2.1
},
"75db68ff6ae1": {
"rss_before_kib": 63720,
"peak_kib": 66496,
"peak_delta_mib": 2.7
}
},
"max_peak_delta_mib": 2.7,
"s3_anon_peak_mib": 492.6,
"if_buffered_mib_per_replica": 159.0
},
{
"concurrency": 10,
"client_rate_bytes_per_s": 2097152,
"file_bytes": 10417403,
"ok_201": 10,
"statuses": [
"201"
],
"wall_seconds": 5.39,
"upload_seconds_max": 5.38,
"replicas": {
"25311601e8f2": {
"rss_before_kib": 63172,
"peak_kib": 63172,
"peak_delta_mib": 0.0
},
"75db68ff6ae1": {
"rss_before_kib": 63720,
"peak_kib": 63720,
"peak_delta_mib": 0.0
}
},
"max_peak_delta_mib": 0.0,
"s3_anon_peak_mib": 487.3,
"if_buffered_mib_per_replica": 49.7
},
{
"concurrency": 20,
"client_rate_bytes_per_s": 2097152,
"file_bytes": 10417403,
"ok_201": 20,
"statuses": [
"201"
],
"wall_seconds": 7.06,
"upload_seconds_max": 7.054,
"replicas": {
"25311601e8f2": {
"rss_before_kib": 63172,
"peak_kib": 63252,
"peak_delta_mib": 0.1
},
"75db68ff6ae1": {
"rss_before_kib": 63720,
"peak_kib": 63736,
"peak_delta_mib": 0.0
}
},
"max_peak_delta_mib": 0.1,
"s3_anon_peak_mib": 472.9,
"if_buffered_mib_per_replica": 99.3
}
]
}
+9
View File
@@ -0,0 +1,9 @@
# 2026-11-05T21:23:45Z commit=n/a host=Linux 6.18.44-fc-v236 x86_64 cpus=2
$ python3 research/upload_memory.py --output evidence/upload-memory.json
{"concurrency": 1, "client_rate_bytes_per_s": "unlimited", "file_bytes": 10417403, "ok_201": 1, "statuses": ["201"], "wall_seconds": 0.26, "upload_seconds_max": 0.26, "replicas": {"25311601e8f2": {"rss_before_kib": 62356, "peak_kib": 62356, "peak_delta_mib": 0.0}, "75db68ff6ae1": {"rss_before_kib": 62564, "peak_kib": 62564, "peak_delta_mib": 0.0}}, "max_peak_delta_mib": 0.0, "s3_anon_peak_mib": 172.0, "if_buffered_mib_per_replica": 5.0}
{"concurrency": 10, "client_rate_bytes_per_s": "unlimited", "file_bytes": 10417403, "ok_201": 10, "statuses": ["201"], "wall_seconds": 2.02, "upload_seconds_max": 2.01, "replicas": {"25311601e8f2": {"rss_before_kib": 62356, "peak_kib": 63720, "peak_delta_mib": 1.3}, "75db68ff6ae1": {"rss_before_kib": 62564, "peak_kib": 63164, "peak_delta_mib": 0.6}}, "max_peak_delta_mib": 1.3, "s3_anon_peak_mib": 491.6, "if_buffered_mib_per_replica": 49.7}
{"concurrency": 20, "client_rate_bytes_per_s": "unlimited", "file_bytes": 10417403, "ok_201": 20, "statuses": ["201"], "wall_seconds": 3.43, "upload_seconds_max": 3.401, "replicas": {"25311601e8f2": {"rss_before_kib": 62632, "peak_kib": 66060, "peak_delta_mib": 3.3}, "75db68ff6ae1": {"rss_before_kib": 62692, "peak_kib": 65976, "peak_delta_mib": 3.2}}, "max_peak_delta_mib": 3.3, "s3_anon_peak_mib": 492.5, "if_buffered_mib_per_replica": 99.3}
{"concurrency": 32, "client_rate_bytes_per_s": "unlimited", "file_bytes": 10417403, "ok_201": 25, "statuses": ["201", "503"], "wall_seconds": 4.62, "upload_seconds_max": 4.591, "replicas": {"25311601e8f2": {"rss_before_kib": 63956, "peak_kib": 66068, "peak_delta_mib": 2.1}, "75db68ff6ae1": {"rss_before_kib": 63720, "peak_kib": 66496, "peak_delta_mib": 2.7}}, "max_peak_delta_mib": 2.7, "s3_anon_peak_mib": 492.6, "if_buffered_mib_per_replica": 159.0}
{"concurrency": 10, "client_rate_bytes_per_s": 2097152, "file_bytes": 10417403, "ok_201": 10, "statuses": ["201"], "wall_seconds": 5.39, "upload_seconds_max": 5.38, "replicas": {"25311601e8f2": {"rss_before_kib": 63172, "peak_kib": 63172, "peak_delta_mib": 0.0}, "75db68ff6ae1": {"rss_before_kib": 63720, "peak_kib": 63720, "peak_delta_mib": 0.0}}, "max_peak_delta_mib": 0.0, "s3_anon_peak_mib": 487.3, "if_buffered_mib_per_replica": 49.7}
{"concurrency": 20, "client_rate_bytes_per_s": 2097152, "file_bytes": 10417403, "ok_201": 20, "statuses": ["201"], "wall_seconds": 7.06, "upload_seconds_max": 7.054, "replicas": {"25311601e8f2": {"rss_before_kib": 63172, "peak_kib": 63252, "peak_delta_mib": 0.1}, "75db68ff6ae1": {"rss_before_kib": 63720, "peak_kib": 63736, "peak_delta_mib": 0.0}}, "max_peak_delta_mib": 0.1, "s3_anon_peak_mib": 472.9, "if_buffered_mib_per_replica": 99.3}
exit=0
+100
View File
@@ -0,0 +1,100 @@
# HAProxy 3.0 — единственная публичная точка входа lab3.
# Бэкенды находятся через DNS Docker (имя сервиса `api` → IP всех реплик), без sticky sessions.
#
# Обнаружение отказа реплики:
# * активная проверка GET /health/ready: inter 1s, после первой ошибки fastinter 500ms, fall 2,
# timeout check 300ms → худший случай обнаружения ≈ 1 + 0.3 + 0.5 + 0.3 ≈ 2.1 с;
# * пассивно: соединение отвергнуто → retry-on conn-failure + redispatch на другую реплику
# (только если запрос ещё не отправлен — безопасно и для неидемпотентных POST).
# * graceful shutdown реплики: SIGTERM → /health/ready = 503 на SHUTDOWN_DRAIN_SECONDS=3 с
# (> fall × fastinter) → LB выводит реплику до того, как она закроет listener.
global
log stdout format raw local0 info
maxconn 4096
defaults
mode http
log global
option httplog
option dontlognull
timeout connect 300ms # сеть Docker: connect < 1 мс; к «мёртвому» IP (kill) нет RST — ждём не дольше 300 мс
timeout check 300ms # проверка не висит 1 с на убитой реплике → быстрее fall
timeout client 60s # lab4: загрузка до 10 МиБ медленным клиентом
timeout server 60s # бездействие сервера; > REQUEST_TIMEOUT_SECONDS (10 с); upload/download — потоки
timeout http-request 10s
timeout http-keep-alive 10s
timeout queue "${LB_QUEUE_TIMEOUT}" # сколько запрос может ждать свободный слот maxconn в очереди LB
retries 2
option redispatch 1
retry-on conn-failure # НЕ empty-response/response-timeout: иначе возможен повтор выполненного POST
unique-id-format %[uuid()] # request_id ответов самого LB: случайный, без IP/портов
default-server inter 1s fastinter 500ms downinter 2s fall 2 rise 2 init-addr none resolvers docker
# Ответы, созданные самим LB, — в формате ошибок API (X-Instance-Id у них нет, это допустимо).
http-error status 503 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Нет доступных реплик API","request_id":"%[unique-id]"}}' hdr X-Request-Id %[unique-id] hdr Retry-After 1
http-error status 502 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Реплика API недоступна","request_id":"%[unique-id]"}}' hdr X-Request-Id %[unique-id]
http-error status 504 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Таймаут реплики API","request_id":"%[unique-id]"}}' hdr X-Request-Id %[unique-id]
resolvers docker
nameserver dns 127.0.0.11:53
resolve_retries 3
timeout resolve 1s
timeout retry 1s
hold valid 2s
hold obsolete 5s # исчезнувший из DNS контейнер убирается из слота через 5 с
accepted_payload_size 8192
frontend api
bind :8080
# Внутренняя диагностика реплик снаружи недоступна.
http-request return status 404 content-type application/json lf-string '{"error":{"code":"not_found","message":"Объект не найден","request_id":"%[unique-id]"}}' hdr X-Request-Id %[unique-id] if { path_beg /internal }
default_backend api
frontend api_ttl
bind :8081
http-request return status 404 content-type application/json lf-string '{"error":{"code":"not_found","message":"Объект не найден","request_id":"%[unique-id]"}}' hdr X-Request-Id %[unique-id] if { path_beg /internal }
default_backend api_ttl
frontend api_fault
bind :8082
http-request return status 404 content-type application/json lf-string '{"error":{"code":"not_found","message":"Объект не найден","request_id":"%[unique-id]"}}' hdr X-Request-Id %[unique-id] if { path_beg /internal }
default_backend api_fault
frontend stats
bind :8404
stats enable
stats uri /stats
stats refresh 2s
stats show-legends
backend api
balance roundrobin # без stickiness: состояние не хранится в реплике
option httpchk
http-check send meth GET uri /health/ready
http-check expect status 200
http-reuse safe
# maxconn: не больше LB_SERVER_MAXCONN одновременных запросов на реплику, излишек ждёт в очереди LB
# (0 = без ограничения). Обоснование значения — трек 5.1 в REPORT.md.
server-template api 8 api:8080 check maxconn "${LB_SERVER_MAXCONN}"
# «Panic mode»: если readiness не проходит НИ У ОДНОЙ реплики (например, упала БД), запросы всё
# равно идут в живые процессы, и клиент получает ответ приложения (401 анониму, 503 unavailable
# в формате API, /health/live = 200), а не безликий 503 LB. Мёртвый процесс → conn-failure → 503 LB.
option allbackups
server-template apibk 8 api:8080 backup resolve-opts allow-dup-ip
backend api_ttl
balance roundrobin
option httpchk
http-check send meth GET uri /health/ready
http-check expect status 200
server-template ttl 2 api-ttl:8080 check
option allbackups
server-template ttlbk 2 api-ttl:8080 backup resolve-opts allow-dup-ip
# Только для теста компенсации (профиль fault). Без сервиса api-fault слоты пусты — бэкенд DOWN.
backend api_fault
balance roundrobin
option httpchk
http-check send meth GET uri /health/ready
http-check expect status 200
server-template fault 1 api-fault:8080 check
View File
+63
View File
@@ -0,0 +1,63 @@
-- 0001: базовая схема lab2. Источник истины — PostgreSQL.
-- Миграция выполняется раннером в одной транзакции и регистрируется в schema_migrations.
CREATE TABLE users (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT users_username_key UNIQUE (username),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100),
CONSTRAINT users_password_hash_kdf CHECK (password_hash LIKE '$scrypt$%')
);
CREATE TABLE chats (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
title text NOT NULL,
created_by uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
);
-- Состав участников неизменен в обязательном API; position сохраняет порядок member_ids из запроса.
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users (id),
position smallint NOT NULL,
PRIMARY KEY (chat_id, user_id),
CONSTRAINT chat_members_position_key UNIQUE (chat_id, position),
CONSTRAINT chat_members_position_range CHECK (position BETWEEN 0 AND 99)
);
-- GET /chats: «чаты пользователя» — поиск по user_id.
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
chat_id uuid NOT NULL,
sender_id uuid NOT NULL,
text text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
-- Отправитель обязан быть участником этого чата: инвариант защищён на уровне БД.
CONSTRAINT messages_sender_is_member FOREIGN KEY (chat_id, sender_id)
REFERENCES chat_members (chat_id, user_id),
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000)
);
-- История: WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT n.
-- Обоснование и EXPLAIN — REPORT.md и evidence/track2/.
CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id);
-- Серверные сессии. Хранится только SHA-256 от токена (токен — 256 бит случайности),
-- поэтому утечка дампа не даёт готовых Bearer-токенов.
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
expires_at timestamptz NOT NULL,
revoked_at timestamptz,
CONSTRAINT sessions_token_hash_len CHECK (octet_length(token_hash) = 32),
CONSTRAINT sessions_expiry_after_creation CHECK (expires_at > created_at)
);
CREATE INDEX sessions_user_idx ON sessions (user_id);
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
@@ -0,0 +1,8 @@
-- 0002: транзакционный outbox инвалидации кэша сессий (уровень 4).
-- Строка пишется в той же транзакции, что и revoked_at. Если Redis недоступен в момент logout,
-- фоновый процесс API повторит инвалидацию после восстановления Redis и только затем снова
-- начнёт читать сессии из кэша.
CREATE TABLE session_cache_invalidations (
token_hash bytea PRIMARY KEY REFERENCES sessions (token_hash) ON DELETE CASCADE,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
@@ -0,0 +1,17 @@
-- 0003 (lab3): общая идемпотентность POST /chats/{chat_id}/messages.
-- Область ключа = пользователь + метод + путь чата + ключ. Единственный идемпотентный endpoint
-- обязательного API — POST сообщения, поэтому метод и шаблон пути фиксированы, а «путь» = chat_id.
-- Миграция аддитивна (expand): код lab2 её не использует и продолжает работать при rolling update.
CREATE TABLE idempotency_keys (
user_id uuid NOT NULL REFERENCES users (id),
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
key text NOT NULL,
request_hash bytea NOT NULL,
message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
PRIMARY KEY (user_id, chat_id, key),
CONSTRAINT idempotency_key_format CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'),
CONSTRAINT idempotency_request_hash_len CHECK (octet_length(request_hash) = 32)
);
-- Очистка ключей старше IDEMPOTENCY_TTL_SECONDS.
CREATE INDEX idempotency_keys_created_idx ON idempotency_keys (created_at);
@@ -0,0 +1,62 @@
-- 0004 (lab4): вложения. Метаданные — здесь, байты — в приватном S3 bucket (ключ назначает сервер).
-- С lab4 текст может быть пустым, если у сообщения есть вложения (правило «пустой текст только с
-- вложениями» проверяет приложение: связь в другой таблице). Expand-изменение: старый код его не нарушает.
ALTER TABLE messages DROP CONSTRAINT messages_text_len;
ALTER TABLE messages ADD CONSTRAINT messages_text_len CHECK (char_length(text) <= 4000);
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),
filename text NOT NULL, -- только для отображения, НЕ путь и НЕ ключ
content_type text NOT NULL,
size_bytes bigint NOT NULL,
sha256 text NOT NULL,
width integer NOT NULL,
height integer NOT NULL,
object_key text NOT NULL,
status text NOT NULL DEFAULT 'ready',
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
updated_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT attachments_object_key_key UNIQUE (object_key),
CONSTRAINT attachments_filename_len CHECK (char_length(filename) BETWEEN 1 AND 255),
CONSTRAINT attachments_content_type CHECK (content_type IN ('image/png', 'image/jpeg')),
CONSTRAINT attachments_size CHECK (size_bytes BETWEEN 1 AND 10485760),
CONSTRAINT attachments_sha256 CHECK (sha256 ~ '^[a-f0-9]{64}$'),
CONSTRAINT attachments_dims CHECK (width > 0 AND height > 0 AND width::bigint * height <= 40000000),
CONSTRAINT attachments_status CHECK (status IN ('ready')) -- lab5 расширит (queued/processing/failed)
);
CREATE INDEX attachments_chat_idx ON attachments (chat_id, created_at);
CREATE INDEX attachments_created_idx ON attachments (created_at);
-- Связь сообщение ↔ вложения (порядок attachment_ids из запроса сохраняется).
CREATE TABLE message_attachments (
message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE,
attachment_id uuid NOT NULL REFERENCES attachments (id),
position smallint NOT NULL,
PRIMARY KEY (message_id, attachment_id),
CONSTRAINT message_attachments_position_key UNIQUE (message_id, position),
CONSTRAINT message_attachments_position_range CHECK (position BETWEEN 0 AND 9)
);
CREATE INDEX message_attachments_attachment_idx ON message_attachments (attachment_id);
-- Журнал намерений загрузки (компенсация S3 ↔ PostgreSQL). Строка фиксируется ДО записи в S3 и
-- удаляется в той же транзакции, что создаёт attachments. Осталась дольше grace period — значит,
-- процесс упал между S3 PUT и COMMIT (или во время загрузки): объект по ключу удаляется очисткой.
CREATE TABLE upload_intents (
object_key text PRIMARY KEY,
attachment_id uuid NOT NULL,
chat_id uuid NOT NULL,
owner_id uuid NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE INDEX upload_intents_created_idx ON upload_intents (created_at);
-- Результаты проверки целостности (reconciler): проблемы, которые нельзя безопасно исправить
-- автоматически (например, утрачен объект вложения, на которое ссылаются сообщения).
CREATE TABLE attachment_integrity (
attachment_id uuid PRIMARY KEY REFERENCES attachments (id) ON DELETE CASCADE,
problem text NOT NULL,
detected_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT attachment_integrity_problem CHECK (problem IN ('missing_object', 'size_mismatch', 'checksum_mismatch'))
);
+16
View File
@@ -0,0 +1,16 @@
# Runtime-зависимости API (точные версии, проверенные на стенде; см. REPORT.md).
starlette==1.7.0
anyio==4.15.1
idna==3.20
typing_extensions==4.16.0
uvicorn==0.54.0
h11==0.16.0
click==8.5.0
psycopg[binary]==3.2.10
psycopg-binary==3.2.10
psycopg-pool==3.2.6
redis==5.2.1
# lab4: асинхронный HTTP-клиент для S3 (SigV4 реализован в src/messenger/s3.py)
httpx==0.28.1
httpcore==1.0.9
certifi==2026.10.18
+98
View File
@@ -0,0 +1,98 @@
#!/usr/bin/env python3
"""Трек 2: стоимость обхода reconciler в зависимости от числа объектов.
Методика: для каждого N в отдельном префиксе bench-<run>/<N>/ создаются N объектов (admin-ключом, в обход
API) и N согласованных строк attachments (COPY через psql). Затем:
1. dry-run — ListObjectsV2 + снимок БД (время, число S3-запросов, пик RSS процесса);
2. dry-run --verify-checksums (только N ≤ --verify-max) — дополнительно GET каждого объекта;
3. уборка как эксперимент на исправление: DELETE строк в БД → N «orphan» → reconcile --apply
--grace-seconds 0 удаляет N объектов (стоимость исправления), повторный dry-run → 0.
Каждый замер выполняется в API-контейнере (`docker compose exec api python -m messenger reconcile`),
поэтому включает старт интерпретатора (~0.5 с). Вывод — JSON (evidence/reconcile-cost.json).
python3 research/reconcile_cost.py --sizes 1000,5000,20000 --output evidence/reconcile-cost.json
"""
import argparse
import json
import shlex
import subprocess
import sys
import time
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "student-tests"))
from common import API_EXEC, PSQL, S3_ADMIN, Client, login, new_user, sql # noqa: E402
def admin(*args, timeout=1800):
script = (ROOT / "student-tests" / "s3_admin.py").read_bytes()
return subprocess.run(shlex.split(S3_ADMIN) + [str(a) for a in args], cwd=ROOT, input=script,
capture_output=True, check=True, timeout=timeout).stdout.decode()
def reconcile(*args):
for _attempt in range(5): # lock может быть кратко занят встроенным janitor (раз в 60 с)
t = time.monotonic()
out = subprocess.run(shlex.split(API_EXEC) + ["python", "-m", "messenger", "reconcile", "--samples", "0"]
+ [str(a) for a in args], cwd=ROOT, capture_output=True, text=True, timeout=3600)
if out.returncode != 1 or "lock" not in out.stderr:
break
time.sleep(1)
if out.returncode not in (0, 2):
raise SystemExit("reconcile failed: " + out.stderr[-500:])
r = json.loads(out.stdout)
return {"wall_seconds_incl_exec": round(time.monotonic() - t, 2), "exit": out.returncode,
"scanned": r["scanned"], "counts": r["counts"], "actions": r["actions"], "cost": r["cost"]}
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default="http://127.0.0.1:8080")
ap.add_argument("--sizes", default="1000,5000,20000")
ap.add_argument("--object-bytes", type=int, default=4096)
ap.add_argument("--verify-max", type=int, default=5000)
ap.add_argument("--output")
a = ap.parse_args()
c = Client(a.base_url, timeout=30)
owner = new_user(c, "cost"); login(c, owner)
chat = c.call("POST", "/api/v1/chats", 201, actor=owner, schema="Chat",
body={"title": "reconcile cost", "member_ids": [owner["id"]]})["json"]
run = "bench-" + uuid.uuid4().hex[:8] + "/"
results = []
for n in [int(x) for x in a.sizes.split(",") if x]:
prefix = "%s%d/" % (run, n)
t = time.monotonic()
lines = admin("seed", prefix, n, a.object_bytes).split("\n")
seed_s = time.monotonic() - t
rows = []
for ln in lines:
if ln.strip():
key, sha, size = ln.split()
rows.append("\t".join([str(uuid.uuid4()), chat["id"], owner["id"], "bench.png", "image/png", size, sha,
"1", "1", key]))
copy = ("\\copy attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, width, height,"
" object_key) FROM STDIN")
subprocess.run(shlex.split(PSQL) + ["-X", "-q", "-v", "ON_ERROR_STOP=1", "-c", copy], cwd=ROOT,
input="\n".join(rows) + "\n", text=True, check=True, timeout=600)
entry = {"n_objects": n, "object_bytes": a.object_bytes, "seed_seconds": round(seed_s, 1),
"dry_run": reconcile("--prefix", prefix, "--grace-seconds", 0)}
if n <= a.verify_max:
entry["dry_run_verify_checksums"] = reconcile("--prefix", prefix, "--grace-seconds", 0, "--verify-checksums")
sql("DELETE FROM attachments WHERE object_key LIKE '%s%%'" % prefix)
entry["apply_delete_orphans"] = reconcile("--prefix", prefix, "--grace-seconds", 0, "--apply")
entry["after_apply"] = reconcile("--prefix", prefix, "--grace-seconds", 0)
results.append(entry)
d = entry["dry_run"]["cost"]
print("N=%d dry-run %.2fs (%d S3 req, rss %d KiB); apply %s; after %s" % (
n, d["total_seconds"], d["s3_requests_total"], d["peak_rss_kib"],
entry["apply_delete_orphans"]["actions"], entry["after_apply"]["counts"]), flush=True)
admin("purge", run)
report = {"method": __doc__.strip().splitlines()[0], "prefix": run, "runs": results}
if a.output:
Path(a.output).write_text(json.dumps(report, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
if __name__ == "__main__":
main()
+153
View File
@@ -0,0 +1,153 @@
#!/usr/bin/env python3
"""Эксперимент (уровень 4): пик RSS API при N одновременных загрузках ~10 МиБ.
Гипотеза: upload потоковый (кусок ≈64 КиБ → валидатор/SHA-256 → S3 PUT), поэтому пик RSS реплики
растёт на O(N × буфер), а не на O(N × размер файла). Если бы тело буферизовалось целиком, 20 загрузок
по 10 МиБ на одной реплике дали бы ≥ +200 МиБ (и упёрлись бы в лимит контейнера 256 МиБ).
Методика (повторяемая): для каждого сценария сбрасываем VmHWM обеих API-реплик
(`python -m messenger stats --reset-peak` внутри контейнера), запускаем N параллельных загрузок
несжимаемого PNG через LB, затем читаем VmHWM/VmRSS. Сценарии: fast (клиент шлёт без пауз) и slow
(клиент шлёт кусками по 64 КиБ со скоростью ~2 МиБ/с — соединения долго держат слот).
python3 research/upload_memory.py --output evidence/upload-memory.json
"""
import argparse
import json
import os
import shlex
import socket
import subprocess
import sys
import threading
import time
import zlib
from pathlib import Path
from urllib.parse import quote, urlsplit
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "student-tests"))
from common import DC, Client, login, new_user # noqa: E402
def big_png(target):
side = int(((target - 4096) / 3) ** 0.5)
rows = b"".join(b"\x00" + os.urandom(side * 3) for _ in range(side))
def chunk(t, d):
return len(d).to_bytes(4, "big") + t + d + zlib.crc32(t + d).to_bytes(4, "big")
ihdr = side.to_bytes(4, "big") + side.to_bytes(4, "big") + bytes([8, 2, 0, 0, 0])
return b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr) + chunk(b"IDAT", zlib.compress(rows, 1)) + chunk(b"IEND", b"")
def replicas():
out = subprocess.run(shlex.split(DC + " ps -q api"), cwd=ROOT, capture_output=True, text=True, check=True)
return [c for c in out.stdout.split() if c]
def stats(cid, reset=False):
cmd = ["docker", "exec", cid, "python", "-m", "messenger", "stats"] + (["--reset-peak"] if reset else [])
return json.loads(subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=30).stdout)
def send(base, token, chat_id, data, rate, results):
u = urlsplit(base)
head = ("POST /api/v1/chats/%s/attachments?filename=%s HTTP/1.1\r\nHost: %s\r\nAuthorization: Bearer %s\r\n"
"Content-Type: image/png\r\nContent-Length: %d\r\nConnection: close\r\n\r\n"
% (chat_id, quote("mem.png"), u.netloc, token, len(data))).encode()
t = time.monotonic()
try:
s = socket.create_connection((u.hostname, u.port or 80), timeout=120)
s.sendall(head)
step = 65536
for i in range(0, len(data), step):
s.sendall(data[i:i + step])
if rate:
time.sleep(step / rate)
resp = b""
while b"\r\n" not in resp:
part = s.recv(4096)
if not part:
break
resp += part
s.close()
status = int(resp.split(b" ", 2)[1]) if resp else 0
except OSError as exc:
status = type(exc).__name__
results.append({"status": status, "seconds": round(time.monotonic() - t, 3)})
def s3_memory_sampler(stop, samples):
"""Пик анонимной памяти контейнера s3 (cgroup memory.stat) — опрос каждые 0.2 с во время сценария."""
cid = subprocess.run(shlex.split(DC + " ps -q s3"), cwd=ROOT, capture_output=True, text=True).stdout.strip()
while not stop.is_set() and cid:
# cgroup v2 (Docker Desktop) или v1 (старые Linux-хосты)
# Анонимная память (без page cache): cgroup v2 memory.stat «anon» (Docker Desktop) или v1 «total_rss».
r = subprocess.run(["docker", "exec", cid, "sh", "-c", "cat /sys/fs/cgroup/memory.stat 2>/dev/null"
" || cat /sys/fs/cgroup/memory/memory.stat"], capture_output=True, text=True)
for line in r.stdout.splitlines():
name, _, value = line.partition(" ")
if name in ("anon", "total_rss") and value.strip().isdigit():
samples.append(int(value))
break
time.sleep(0.2)
def scenario(base, actor, chat, data, n, rate):
ids = replicas()
stop, s3mem = threading.Event(), []
sampler = threading.Thread(target=s3_memory_sampler, args=(stop, s3mem))
sampler.start()
before = {cid[:12]: stats(cid, reset=True)["memory"] for cid in ids}
results, threads = [], []
for _ in range(n):
threads.append(threading.Thread(target=send, args=(base, actor["token"], chat["id"], data, rate, results)))
t = time.monotonic()
for th in threads:
th.start()
for th in threads:
th.join()
wall = time.monotonic() - t
stop.set(); sampler.join()
after = {cid[:12]: stats(cid)["memory"] for cid in ids}
per = {k: {"rss_before_kib": before[k]["rss_kib"], "peak_kib": after[k]["peak_rss_kib"],
"peak_delta_mib": round((after[k]["peak_rss_kib"] - before[k]["rss_kib"]) / 1024, 1)} for k in after}
ok = sum(1 for r in results if r["status"] == 201)
return {"concurrency": n, "client_rate_bytes_per_s": rate or "unlimited", "file_bytes": len(data),
"ok_201": ok, "statuses": sorted({str(r["status"]) for r in results}), "wall_seconds": round(wall, 2),
"upload_seconds_max": max(r["seconds"] for r in results), "replicas": per,
"max_peak_delta_mib": max(v["peak_delta_mib"] for v in per.values()),
"s3_anon_peak_mib": round(max(s3mem) / 2**20, 1) if s3mem else None,
"if_buffered_mib_per_replica": round(n / max(1, len(per)) * len(data) / 2**20, 1)}
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default=os.environ.get("BASE_URL", "http://127.0.0.1:8080"))
ap.add_argument("--size", type=int, default=10 * 2**20 - 64 * 1024)
ap.add_argument("--levels", default="1,10,20,32")
ap.add_argument("--slow-levels", default="10,20")
ap.add_argument("--slow-rate", type=int, default=2 * 2**20)
ap.add_argument("--output")
a = ap.parse_args()
c = Client(a.base_url, timeout=30)
actor = new_user(c, "mem"); login(c, actor)
chat = c.call("POST", "/api/v1/chats", 201, actor=actor, schema="Chat",
body={"title": "memory", "member_ids": [actor["id"]]})["json"]
data = big_png(a.size)
runs = []
for n in [int(x) for x in a.levels.split(",") if x]:
runs.append(scenario(a.base_url, actor, chat, data, n, 0))
print(json.dumps(runs[-1], ensure_ascii=False))
for n in [int(x) for x in a.slow_levels.split(",") if x]:
runs.append(scenario(a.base_url, actor, chat, data, n, a.slow_rate))
print(json.dumps(runs[-1], ensure_ascii=False))
report = {"hypothesis": "peak RSS grows by O(N*chunk), not O(N*file)", "file_mib": round(len(data) / 2**20, 2),
"limits": {"UPLOAD_CONCURRENCY_per_replica": 16, "api_memory_limit": "256M", "s3_memory_limit": "1G",
"s3_concurrentUploadLimitMB": 96}, "runs": runs}
if a.output:
Path(a.output).write_text(json.dumps(report, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
if __name__ == "__main__":
main()
+111
View File
@@ -0,0 +1,111 @@
# Windows PowerShell 5.1+ equivalent of scripts/collect-evidence.sh (lab4).
# Starts the Compose stand (LB + API replicas + migrate + PostgreSQL + Redis + SeaweedFS S3 + s3-init),
# runs every check and writes outputs to evidence\ (no tokens/passwords/S3 keys). Stops/restarts containers
# during failover/restart/S3 outage tests; volumes are never removed. Takes ~15-20 minutes.
# powershell -NoProfile -ExecutionPolicy Bypass -File scripts\collect-evidence.ps1 [-SkipFailures] [-SkipResearch]
param([switch]$SkipFailures, [switch]$SkipResearch)
$ErrorActionPreference = 'Continue'
$root = Split-Path -Parent $PSScriptRoot
Set-Location $root
$env:PYTHONUTF8 = '1'
$env:PYTHONIOENCODING = 'utf-8'
# IPv4 explicitly: on Windows 'localhost' resolves to ::1 first; the LB listens on 127.0.0.1 only.
$env:NO_PROXY = '127.0.0.1,localhost'
$B = 'http://127.0.0.1:8080'
$env:BASE_URL = $B
$env:TTL_BASE_URL = 'http://127.0.0.1:8081'
$ev = Join-Path $root 'evidence'
New-Item -ItemType Directory -Force -Path $ev | Out-Null
# Full path of the Python APPLICATION: a bare 'py' would resolve to a PowerShell function first.
$pyApp = Get-Command py -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1
$pythonApp = Get-Command python -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1
if ($pyApp) { $script:PyExe = $pyApp.Source; $script:PyPre = @('-3') }
elseif ($pythonApp) { $script:PyExe = $pythonApp.Source; $script:PyPre = @() }
else { throw 'Python 3.9+ not found (install from python.org, enable "Add to PATH")' }
function Invoke-Python { & $script:PyExe @script:PyPre @args }
function Dc { & docker compose --env-file .env @args }
$hookStop = if ($IsLinux -or $IsMacOS) { 'scripts/stop-one.sh' } else { 'scripts\stop-one.cmd' }
$hookRestart = if ($IsLinux -or $IsMacOS) { 'scripts/restart.sh' } else { 'scripts\restart.cmd' }
$startReplicas = Join-Path $PSScriptRoot 'start-replicas.ps1'
function Get-Stamp {
$commit = 'n/a'
if (Get-Command git -ErrorAction SilentlyContinue) {
$c = (& git rev-parse --short HEAD 2>$null)
if ($LASTEXITCODE -eq 0 -and $c) { $commit = $c }
}
'# ' + (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ') + ' commit=' + $commit + ' host=' + [Environment]::OSVersion.VersionString + ' cpus=' + [Environment]::ProcessorCount
}
function Invoke-Step([string]$name, [string]$title, [scriptblock]$block) {
Write-Host ('>>> ' + $name) -ForegroundColor Cyan
$global:LASTEXITCODE = 0
$lines = @(& $block 2>&1 | ForEach-Object { "$_" })
$code = $global:LASTEXITCODE
Set-Content -Path (Join-Path $ev ($name + '.txt')) -Encoding UTF8 -Value (@((Get-Stamp), ('$ ' + $title)) + $lines + @('exit=' + $code))
$lines | Select-Object -Last 2 | ForEach-Object { Write-Host (' ' + $_) }
if ($code -ne 0) { Write-Host (' exit=' + $code + ' (see evidence\' + $name + '.txt)') -ForegroundColor Yellow }
}
& docker version --format '{{.Server.Version}}' *> $null
if ($LASTEXITCODE -ne 0) { throw 'Docker is not running: start Docker Desktop first' }
& (Join-Path $PSScriptRoot 'init-secrets.ps1')
Set-Location $root
Write-Host '>>> docker compose up (build, wait for healthchecks)' -ForegroundColor Cyan
Dc --profile ttl up -d --build --wait
if ($LASTEXITCODE -ne 0) { Dc logs --tail=80; throw 'docker compose up failed' }
Invoke-Step 'stack' 'docker version; compose images; ps' { & docker version --format 'docker {{.Server.Version}}'; Dc version; Dc --profile ttl images; Dc --profile ttl ps -a }
Invoke-Step 's3-bootstrap' 'docker compose logs s3-init' { Dc logs --no-log-prefix s3-init }
Invoke-Step 's3-bootstrap-rerun' 'docker compose run --rm --no-deps s3-init # idempotent' { Dc run --rm --no-deps s3-init }
Invoke-Step 's3-check' 'docker compose exec api python -m messenger s3-check' { Dc exec -T api python -m messenger s3-check }
Invoke-Step 'api-no-local-files' 'docker inspect api: ReadonlyRootfs, tmpfs; files in /tmp' {
foreach ($cid in (Dc ps -q api)) {
& docker inspect -f '{{.Name}} ReadonlyRootfs={{.HostConfig.ReadonlyRootfs}} Tmpfs={{json .HostConfig.Tmpfs}} Mounts={{range .Mounts}}{{.Type}}:{{.Destination}} {{end}}' $cid
& docker exec $cid sh -c 'echo tmp: $(ls -A /tmp); touch /app/x 2>&1 | head -1'
}
}
Invoke-Step 'instances' 'X-Instance-Id of 6 requests via LB' {
1..6 | ForEach-Object { (Invoke-WebRequest -UseBasicParsing "$B/health/live").Headers['X-Instance-Id'] }
}
Invoke-Step 'make-check' 'python scripts/check_contract.py' { Invoke-Python scripts/check_contract.py }
Invoke-Step 'smoke' "python tests/smoke.py --base-url $B" { Invoke-Python tests/smoke.py --base-url $B }
Invoke-Step 'test-attachments' 'python student-tests/test_attachments.py' { Invoke-Python student-tests/test_attachments.py }
Invoke-Step 'test-api' 'python student-tests/test_api.py' { Invoke-Python student-tests/test_api.py }
Invoke-Step 'test-idempotency' 'python student-tests/test_idempotency.py' { Invoke-Python student-tests/test_idempotency.py }
Invoke-Step 'test-expiry' 'python student-tests/test_expiry.py # api-ttl via LB :8081' { Invoke-Python student-tests/test_expiry.py }
Invoke-Step 'test-cache-race' 'docker compose run api: python student-tests/test_cache_race.py' {
Dc run --rm --no-deps -T -v ((Join-Path $root 'student-tests') + ':/app/student-tests:ro') --entrypoint python api student-tests/test_cache_race.py
}
Set-Content -Path (Join-Path $ev 'failover-hook.txt') -Encoding UTF8 -Value @()
foreach ($i in 1, 2) {
Invoke-Step ('failover-' + $i) ('python tests/resilience.py --mode failover --action-script ' + $hookStop) {
Invoke-Python tests/resilience.py --mode failover --action-script $hookStop --base-url $B
}
Invoke-Step ('restore-' + $i) 'scripts\start-replicas.ps1' { & $startReplicas }
}
Set-Content -Path (Join-Path $ev 'restart-hook.txt') -Encoding UTF8 -Value @()
Invoke-Step 'persistence' ('python tests/resilience.py --mode persistence --action-script ' + $hookRestart) {
Invoke-Python tests/resilience.py --mode persistence --action-script $hookRestart --base-url $B
}
if (-not $SkipFailures) {
Invoke-Step 'test-storage-failures' 'python student-tests/test_storage_failures.py # stops/starts s3, fault profile' { Invoke-Python student-tests/test_storage_failures.py }
Invoke-Step 'test-failures' 'python student-tests/test_failures.py # stops/starts redis and postgres' { Invoke-Python student-tests/test_failures.py }
}
if (-not $SkipResearch) {
Invoke-Step 'upload-memory' 'python research/upload_memory.py' { Invoke-Python research/upload_memory.py --output evidence/upload-memory.json }
Invoke-Step 'test-reconcile' 'python student-tests/test_reconcile.py # track 2' { Invoke-Python student-tests/test_reconcile.py }
Invoke-Step 'reconcile-cost' 'python research/reconcile_cost.py --sizes 1000,5000,20000' {
Invoke-Python research/reconcile_cost.py --sizes 1000,5000,20000 --output evidence/reconcile-cost.json
}
}
Invoke-Step 'reconcile-dry-run' 'docker compose exec api python -m messenger reconcile --samples 5' {
Dc exec -T api python -m messenger reconcile --samples 5
'reconcile_exit=' + $LASTEXITCODE
$global:LASTEXITCODE = 0
}
Invoke-Step 'migrations-rerun' 'docker compose run --rm --no-deps migrate' { Dc run --rm --no-deps migrate }
Invoke-Step 'load' 'python tests/load.py --duration 30 --concurrency 4' {
Invoke-Python tests/load.py --base-url $B --duration 30 --concurrency 4 --output evidence/load.json
}
Write-Host 'Done: evidence collected in evidence\' -ForegroundColor Green
+45
View File
@@ -0,0 +1,45 @@
#!/bin/sh
# Полный прогон доказательств lab4 на Compose-стенде; вывод — evidence/ (без токенов, паролей и ключей S3).
# Останавливает/перезапускает контейнеры стенда (failover, restart, отказы S3/БД/Redis, fault-профиль).
# Volumes не удаляются. Длительность ≈ 15–20 мин.
set -eu
cd "$(dirname "$0")/.."
. scripts/lib.sh
PY=${PYTHON:-python3}
B=${BASE_URL:-http://127.0.0.1:8080}
export BASE_URL=$B TTL_BASE_URL=${TTL_BASE_URL:-http://127.0.0.1:8081} NO_PROXY=127.0.0.1,localhost no_proxy=127.0.0.1,localhost
mkdir -p evidence
stamp() { echo "# $(now) commit=$(git rev-parse --short HEAD 2>/dev/null || echo n/a) host=$(uname -srm) cpus=$(getconf _NPROCESSORS_ONLN)"; }
run() { name=$1; shift; { stamp; echo "\$ $*"; "$@" 2>&1; echo "exit=$?"; } > "evidence/$name.txt" || true; tail -2 "evidence/$name.txt"; }
./scripts/init-secrets.sh
dc --profile ttl up -d --build --wait
{ stamp; docker version --format 'docker {{.Server.Version}}'; dc version; dc --profile ttl images; dc --profile ttl ps -a; state; } > evidence/stack.txt 2>&1
run s3-bootstrap dc logs --no-log-prefix s3-init
run s3-bootstrap-rerun dc run --rm --no-deps s3-init
run s3-check dc exec -T api python -m messenger s3-check
run api-no-local-files sh -c "for c in \$(docker compose --env-file .env ps -q api); do docker inspect -f '{{.Name}} ReadonlyRootfs={{.HostConfig.ReadonlyRootfs}} Tmpfs={{json .HostConfig.Tmpfs}} Mounts={{range .Mounts}}{{.Type}}:{{.Destination}} {{end}}' \$c; docker exec \$c sh -c 'echo tmp: \$(ls -A /tmp); touch /app/x 2>&1 | head -1'; done"
run instances sh -c "for i in 1 2 3 4 5 6; do curl -s -o /dev/null -D - $B/health/live | grep -i x-instance-id; done"
run make-check make check
run smoke $PY tests/smoke.py --base-url "$B"
run test-attachments $PY student-tests/test_attachments.py
run test-api $PY student-tests/test_api.py
run test-idempotency $PY student-tests/test_idempotency.py
run test-expiry $PY student-tests/test_expiry.py
run test-cache-race make test-cache-race
: > evidence/failover-hook.txt
run failover-1 $PY tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url "$B"
run restore-1 ./scripts/start-replicas.sh
run failover-2 $PY tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url "$B"
run restore-2 ./scripts/start-replicas.sh
: > evidence/restart-hook.txt
run persistence $PY tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url "$B"
run test-storage-failures $PY student-tests/test_storage_failures.py
run test-failures $PY student-tests/test_failures.py
run upload-memory $PY research/upload_memory.py --output evidence/upload-memory.json
run test-reconcile $PY student-tests/test_reconcile.py
run reconcile-cost $PY research/reconcile_cost.py --sizes 1000,5000,20000 --output evidence/reconcile-cost.json
run reconcile-dry-run sh -c "docker compose --env-file .env exec -T api python -m messenger reconcile --samples 5; echo reconcile_exit=\$?"
run migrations-rerun dc run --rm --no-deps migrate
run load $PY tests/load.py --base-url "$B" --duration 30 --concurrency 4 --output evidence/load.json
echo "evidence collected in evidence/"
+64
View File
@@ -0,0 +1,64 @@
# Windows PowerShell 5.1+ version of scripts/init-secrets.sh.
# Creates local synthetic secrets in secrets\ and .env (both git-ignored).
# Idempotent: existing files are NOT overwritten. Values are never printed.
$ErrorActionPreference = 'Stop'
$root = Split-Path -Parent $PSScriptRoot
Set-Location $root
New-Item -ItemType Directory -Force -Path (Join-Path $root 'secrets'), (Join-Path $root 'backups') | Out-Null
$ascii = New-Object System.Text.ASCIIEncoding
function New-Hex {
$bytes = New-Object byte[] 24
$rng = [System.Security.Cryptography.RandomNumberGenerator]::Create()
$rng.GetBytes($bytes)
($bytes | ForEach-Object { $_.ToString('x2') }) -join ''
}
function Set-SecretFile([string]$name, [string]$value) {
$path = Join-Path (Join-Path $root 'secrets') $name
if (-not (Test-Path $path)) {
# No BOM, no trailing CR/LF: the value is read verbatim inside Linux containers.
[System.IO.File]::WriteAllText($path, $value, $ascii)
}
}
function Get-SecretFile([string]$name) {
([System.IO.File]::ReadAllText((Join-Path (Join-Path $root 'secrets') $name))).Trim()
}
Set-SecretFile 'postgres_password' (New-Hex)
Set-SecretFile 'redis_password' (New-Hex)
$pg = Get-SecretFile 'postgres_password'
$rd = Get-SecretFile 'redis_password'
Set-SecretFile 'database_url' ("postgresql://messenger:" + $pg + "@postgres:5432/messenger")
Set-SecretFile 'cache_url' ("redis://:" + $rd + "@redis:6379/0")
# S3 (SeaweedFS): two identities. admin - only for bucket bootstrap (s3-init service);
# messenger-api - Read/Write/List ONLY on the attachments bucket (cannot create/delete buckets).
function New-KeyId {
$chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
$bytes = New-Object byte[] 20
[System.Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($bytes)
($bytes | ForEach-Object { $chars[$_ % $chars.Length] }) -join ''
}
Set-SecretFile 's3_admin_access_key_id' (New-KeyId)
Set-SecretFile 's3_admin_secret_access_key' (New-Hex)
Set-SecretFile 's3_access_key_id' (New-KeyId)
Set-SecretFile 's3_secret_access_key' (New-Hex)
$bucket = 'messenger-attachments'
$envPath = Join-Path $root '.env'
if (Test-Path $envPath) {
$line = Select-String -Path $envPath -Pattern '^S3_BUCKET=(.+)$' | Select-Object -First 1
if ($line) { $bucket = $line.Matches[0].Groups[1].Value.Trim() }
}
$cfgPath = Join-Path (Join-Path $root 'secrets') 's3_config.json'
if (-not (Test-Path $cfgPath)) {
$cfg = [ordered]@{ identities = @(
[ordered]@{ name = 'admin'; credentials = @([ordered]@{ accessKey = (Get-SecretFile 's3_admin_access_key_id'); secretKey = (Get-SecretFile 's3_admin_secret_access_key') });
actions = @('Admin', 'Read', 'List', 'Tagging', 'Write') },
[ordered]@{ name = 'messenger-api'; credentials = @([ordered]@{ accessKey = (Get-SecretFile 's3_access_key_id'); secretKey = (Get-SecretFile 's3_secret_access_key') });
actions = @(('Read:' + $bucket), ('Write:' + $bucket), ('List:' + $bucket)) }
) }
[System.IO.File]::WriteAllText($cfgPath, ($cfg | ConvertTo-Json -Depth 6), $ascii)
}
if (-not (Test-Path (Join-Path $root '.env'))) {
Copy-Item (Join-Path $root '.env.example') (Join-Path $root '.env')
}
Write-Output 'secrets\ and .env are ready (values not shown).'
+40
View File
@@ -0,0 +1,40 @@
#!/bin/sh
# Создаёт локальные синтетические secrets для стенда (каталог secrets/ в .gitignore).
# Идемпотентно: существующие файлы НЕ перезаписываются (иначе пароль разойдётся с уже
# инициализированным volume PostgreSQL). Значения не печатаются.
set -eu
cd "$(dirname "$0")/.."
umask 077
mkdir -p secrets backups
chmod 700 secrets
gen() { python3 -c 'import secrets; print(secrets.token_hex(24))'; }
if [ ! -f secrets/postgres_password ]; then gen > secrets/postgres_password; fi
if [ ! -f secrets/redis_password ]; then gen > secrets/redis_password; fi
PG=$(cat secrets/postgres_password)
RD=$(cat secrets/redis_password)
[ -f secrets/database_url ] || printf 'postgresql://messenger:%s@postgres:5432/messenger\n' "$PG" > secrets/database_url
[ -f secrets/cache_url ] || printf 'redis://:%s@redis:6379/0\n' "$RD" > secrets/cache_url
# S3 (SeaweedFS): две identity. admin — только для bootstrap bucket (сервис s3-init);
# api — права Read/Write/List ТОЛЬКО на bucket вложений (не может создавать/удалять бакеты).
keyid() { python3 -c 'import secrets,string; print("".join(secrets.choice(string.ascii_uppercase+string.digits) for _ in range(20)))'; }
[ -f secrets/s3_admin_access_key_id ] || keyid > secrets/s3_admin_access_key_id
[ -f secrets/s3_admin_secret_access_key ] || gen > secrets/s3_admin_secret_access_key
[ -f secrets/s3_access_key_id ] || keyid > secrets/s3_access_key_id
[ -f secrets/s3_secret_access_key ] || gen > secrets/s3_secret_access_key
BUCKET=$(grep -E '^S3_BUCKET=' .env 2>/dev/null | cut -d= -f2); BUCKET=${BUCKET:-messenger-attachments}
[ -f secrets/s3_config.json ] || python3 - "$BUCKET" > secrets/s3_config.json <<'PY'
import json, sys
b = sys.argv[1]
r = lambda n: open("secrets/" + n).read().strip()
print(json.dumps({"identities": [
{"name": "admin", "credentials": [{"accessKey": r("s3_admin_access_key_id"), "secretKey": r("s3_admin_secret_access_key")}],
"actions": ["Admin", "Read", "List", "Tagging", "Write"]},
{"name": "messenger-api", "credentials": [{"accessKey": r("s3_access_key_id"), "secretKey": r("s3_secret_access_key")}],
"actions": ["Read:" + b, "Write:" + b, "List:" + b]}]}, indent=1))
PY
# Файлы монтируются в контейнеры как /run/secrets/*; процесс API работает под uid 10001,
# поэтому файл должен быть читаем внутри контейнера. Каталог secrets/ закрыт (700) на хосте.
chmod 644 secrets/*
[ -f .env ] || cp .env.example .env
mkdir -p backups
echo "secrets/ and .env are ready (values not shown)."
+19
View File
@@ -0,0 +1,19 @@
# Общие функции хуков (POSIX sh). Подключается: . "$(dirname "$0")/lib.sh"
cd "$(dirname "$0")/.."
ENV_FILE=${ENV_FILE:-.env}
dc() { docker compose --env-file "$ENV_FILE" "$@"; }
now() { date -u +%FT%TZ; }
# Состояние всех контейнеров проекта: сервис, имя, статус, StartedAt, PID, alias реплики API.
state() {
for cid in $(dc ps -a -q); do
docker inspect -f '{{index .Config.Labels "com.docker.compose.service"}} {{.Name}} status={{.State.Status}} started={{.State.StartedAt}} pid={{.State.Pid}}' "$cid" |
sed 's# /# #'
done | sort
}
# Контейнер API-реплики по её X-Instance-Id (alias пишется репликой в /tmp/instance-id).
container_of() {
for cid in $(dc ps -q api); do
if [ "$(docker exec "$cid" cat /tmp/instance-id 2>/dev/null)" = "$1" ]; then echo "$cid"; return 0; fi
done
return 1
}
+4
View File
@@ -0,0 +1,4 @@
@echo off
rem Windows wrapper: tests\resilience.py starts the hook directly; .cmd runs without a shell.
powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0restart.ps1"
exit /b %ERRORLEVEL%
+39
View File
@@ -0,0 +1,39 @@
# Windows PowerShell version of scripts/restart.sh (persistence hook): restart LB, ALL API replicas,
# PostgreSQL, Redis and S3 keeping volumes. State before/after -> evidence\restart-hook.txt
$ErrorActionPreference = 'Continue'
$root = Split-Path -Parent $PSScriptRoot
Set-Location $root
$envFile = if ($env:ENV_FILE) { $env:ENV_FILE } else { '.env' }
$log = Join-Path $root 'evidence\restart-hook.txt'
function Dc { & docker compose --env-file $envFile @args 2>$null | Out-Null; if ($LASTEXITCODE -ne 0) { throw ('docker compose ' + ($args -join ' ') + ' failed') } }
function Get-State {
foreach ($cid in (& docker compose --env-file $envFile ps -a -q)) {
& docker inspect -f '{{index .Config.Labels "com.docker.compose.service"}} {{.Name}} status={{.State.Status}} started={{.State.StartedAt}} pid={{.State.Pid}}' $cid
}
& docker volume ls --filter label=com.docker.compose.project=mtusi-lab4 --format 'volume {{.Name}}'
}
try {
Add-Content -Path $log -Encoding UTF8 -Value ('== ' + (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ') + ' before restart')
Add-Content -Path $log -Encoding UTF8 -Value (Get-State)
$ttl = @(& docker compose --env-file $envFile ps -q api-ttl 2>$null).Count -gt 0
Dc stop lb api
if ($ttl) { Dc stop api-ttl }
Dc restart postgres redis s3
# Wait for healthy storages (S3: gateway + master leader) before starting API and LB.
foreach ($svc in 'postgres', 'redis', 's3') {
$cid = (& docker compose --env-file $envFile ps -q $svc | Select-Object -First 1)
for ($i = 0; $i -lt 120; $i++) {
if ((& docker inspect -f '{{.State.Health.Status}}' $cid) -eq 'healthy') { break }
Start-Sleep -Milliseconds 500
}
}
Dc start api
if ($ttl) { Dc start api-ttl }
Dc start lb
Add-Content -Path $log -Encoding UTF8 -Value ('== ' + (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ') + ' after restart')
Add-Content -Path $log -Encoding UTF8 -Value (Get-State)
exit 0
} catch {
[Console]::Error.WriteLine($_.Exception.Message)
exit 1
}
+21
View File
@@ -0,0 +1,21 @@
#!/bin/sh
# Persistence hook: перезапускает LB, ВСЕ API-реплики и все хранилища (PostgreSQL, Redis, S3),
# сохраняя volumes. Никаких down -v / FLUSH / повторного seed. Миграции повторно не нужны.
# Состояние контейнеров до/после (StartedAt, PID) — в evidence/restart-hook.txt.
set -eu
. "$(dirname "$0")/lib.sh"
LOG=${RESTART_EVIDENCE:-evidence/restart-hook.txt}
{ echo "== $(now) before restart"; state; docker volume ls --filter label=com.docker.compose.project=mtusi-lab4 --format 'volume {{.Name}}'; } >> "$LOG"
running_ttl=$(dc ps -q api-ttl 2>/dev/null || true)
dc stop lb api >/dev/null 2>&1
[ -z "$running_ttl" ] || dc stop api-ttl >/dev/null 2>&1
dc restart postgres redis s3 >/dev/null 2>&1
# Дождаться healthy хранилищ (S3: шлюз + выбранный лидер master), затем поднимать API и LB.
for svc in postgres redis s3; do
i=0; cid=$(dc ps -q "$svc")
until [ "$(docker inspect -f '{{.State.Health.Status}}' "$cid")" = healthy ] || [ $i -ge 120 ]; do i=$((i + 1)); sleep 0.5; done
done
dc start api >/dev/null 2>&1
[ -z "$running_ttl" ] || dc start api-ttl >/dev/null 2>&1
dc start lb >/dev/null 2>&1
{ echo "== $(now) after restart"; state; docker volume ls --filter label=com.docker.compose.project=mtusi-lab4 --format 'volume {{.Name}}'; } >> "$LOG"
+35
View File
@@ -0,0 +1,35 @@
#!/bin/sh
# Rolling update API-реплик без остановки сервиса (Compose).
# 1. собрать новый образ (старые контейнеры продолжают работать на старом image id);
# 2. применить миграции ОДИН раз (one-shot migrate). Миграции обязаны быть expand-only
# (совместимы с работающей версией), см. REPORT.md;
# 3. для каждой старой реплики: поднять одну новую (--scale N+1 --no-recreate), дождаться
# healthy, затем остановить старую через SIGTERM (drain 3 с, LB выводит её) и удалить.
# Число готовых реплик во время замены не опускается ниже N. Журнал — evidence/rolling-update.txt.
set -eu
. "$(dirname "$0")/lib.sh"
LOG=${ROLLING_EVIDENCE:-evidence/rolling-update.txt}
VERSION=${APP_VERSION:-$(date -u +%Y%m%d%H%M%S)}
BUILD_CMD=${BUILD_CMD:-"docker compose --env-file $ENV_FILE build --build-arg APP_VERSION=$VERSION api"}
wait_healthy() { # $1 = container id
i=0
while [ "$(docker inspect -f '{{.State.Health.Status}}' "$1")" != healthy ]; do
i=$((i + 1)); [ $i -le 120 ] || { echo "replica $1 not healthy" >&2; return 1; }
sleep 0.5
done
}
old=$(dc ps -q api)
n=$(echo "$old" | wc -w)
{ echo "== $(now) rolling update start: $n replicas, new version $VERSION"; for c in $old; do docker inspect -f 'old {{.Name}} image={{.Image}}' "$c"; done; } >> "$LOG"
$BUILD_CMD >/dev/null
dc run --rm --no-deps migrate >> "$LOG" 2>&1
for c in $old; do
before=$(dc ps -q api)
dc up -d --no-deps --no-recreate --scale api=$((n + 1)) api >/dev/null 2>&1
new=$(for x in $(dc ps -q api); do echo "$before" | grep -q "$x" || echo "$x"; done)
wait_healthy "$new"
echo "$(now) new $(docker inspect -f '{{.Name}} image={{.Image}}' "$new") healthy; stopping old $(docker inspect -f '{{.Name}}' "$c")" >> "$LOG"
docker stop -t 15 "$c" >/dev/null
docker rm "$c" >/dev/null
done
{ echo "== $(now) rolling update done"; for c in $(dc ps -q api); do docker inspect -f 'now {{.Name}} image={{.Image}} health={{.State.Health.Status}}' "$c"; done; } >> "$LOG"
+14
View File
@@ -0,0 +1,14 @@
# Windows PowerShell version of scripts/start-replicas.sh: start stopped API replicas, wait for healthy.
$ErrorActionPreference = 'Continue'
$root = Split-Path -Parent $PSScriptRoot
Set-Location $root
$envFile = if ($env:ENV_FILE) { $env:ENV_FILE } else { '.env' }
$ids = @(& docker compose --env-file $envFile ps -a -q api)
foreach ($cid in $ids) { & docker start $cid | Out-Null }
for ($i = 0; $i -lt 120; $i++) {
$bad = @($ids | Where-Object { (& docker inspect -f '{{.State.Health.Status}}' $_) -ne 'healthy' }).Count
if ($bad -eq 0) { break }
Start-Sleep -Milliseconds 500
}
foreach ($cid in $ids) { & docker inspect -f '{{.Name}} {{.State.Status}} {{.State.Health.Status}}' $cid }
if ($bad -ne 0) { exit 1 }
+16
View File
@@ -0,0 +1,16 @@
#!/bin/sh
# Восстанавливает остановленные API-реплики (после stop-one) и ждёт их healthcheck (≤60 с).
set -eu
. "$(dirname "$0")/lib.sh"
for cid in $(dc ps -a -q api); do docker start "$cid" >/dev/null; done
i=0
while [ $i -lt 120 ]; do
bad=0
for cid in $(dc ps -a -q api); do
[ "$(docker inspect -f '{{.State.Health.Status}}' "$cid")" = healthy ] || bad=1
done
[ $bad -eq 0 ] && break
i=$((i + 1)); sleep 0.5
done
state | grep '^api '
[ $bad -eq 0 ]
+4
View File
@@ -0,0 +1,4 @@
@echo off
rem Windows wrapper: tests\resilience.py starts the hook directly; .cmd runs without a shell.
powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0stop-one.ps1"
exit /b %ERRORLEVEL%
+30
View File
@@ -0,0 +1,30 @@
# Windows PowerShell version of scripts/stop-one.sh (failover hook). Stops EXACTLY ONE API replica whose
# X-Instance-Id is in $env:TARGET_INSTANCE_ID and leaves it stopped. DB/Redis/LB/volumes untouched.
# Restore afterwards: scripts\start-replicas.ps1
$ErrorActionPreference = 'Continue'
$root = Split-Path -Parent $PSScriptRoot
Set-Location $root
$envFile = if ($env:ENV_FILE) { $env:ENV_FILE } else { '.env' }
$log = Join-Path $root 'evidence\failover-hook.txt'
if (-not $env:TARGET_INSTANCE_ID) { [Console]::Error.WriteLine('TARGET_INSTANCE_ID is required'); exit 2 }
function Get-State {
foreach ($cid in (& docker compose --env-file $envFile ps -a -q)) {
& docker inspect -f '{{index .Config.Labels "com.docker.compose.service"}} {{.Name}} status={{.State.Status}} started={{.State.StartedAt}} pid={{.State.Pid}}' $cid
}
}
$target = $null
foreach ($cid in (& docker compose --env-file $envFile ps -q api)) {
$id = (& docker exec $cid cat /tmp/instance-id 2>$null)
if ($id -and $id.Trim() -eq $env:TARGET_INSTANCE_ID) { $target = $cid }
}
if (-not $target) { [Console]::Error.WriteLine('no running api replica with this id'); exit 1 }
$name = (& docker inspect -f '{{.Name}}' $target).TrimStart('/')
$stamp = (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ')
Add-Content -Path $log -Encoding UTF8 -Value ("== $stamp stop-one target=" + $env:TARGET_INSTANCE_ID + " container=$name")
Add-Content -Path $log -Encoding UTF8 -Value (Get-State)
& docker stop -t 15 $target | Out-Null
if ($LASTEXITCODE -ne 0) { exit 1 }
$stamp = (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ')
Add-Content -Path $log -Encoding UTF8 -Value ("== $stamp after stop")
Add-Content -Path $log -Encoding UTF8 -Value (Get-State)
exit 0
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
# Failover hook: останавливает РОВНО ОДНУ API-реплику — ту, чей X-Instance-Id передан тестом в
# TARGET_INSTANCE_ID, — и оставляет её остановленной. БД, Redis, LB и volumes не трогает.
# docker stop → SIGTERM → реплика 3 с отвечает 503 на /health/ready (LB выводит её), затем закрывает
# listener и дожидается запросов в полёте. Возврат ≈ 4 с (< 10 с). Восстановление: scripts/start-replicas.sh
set -eu
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
. "$(dirname "$0")/lib.sh"
LOG=${FAILOVER_EVIDENCE:-evidence/failover-hook.txt}
cid=$(container_of "$TARGET_INSTANCE_ID") || { echo "no running api replica with id $TARGET_INSTANCE_ID" >&2; exit 1; }
name=$(docker inspect -f '{{.Name}}' "$cid" | tr -d /)
{ echo "== $(now) stop-one target=$TARGET_INSTANCE_ID container=$name"; state; } >> "$LOG"
docker stop -t 15 "$cid" >/dev/null
{ echo "== $(now) after stop"; state; } >> "$LOG"
+2
View File
@@ -0,0 +1,2 @@
"""MTUSI messenger API, lab3."""
__version__ = "3.0.0"
+223
View File
@@ -0,0 +1,223 @@
"""Точка входа: python -m messenger [serve|migrate|healthcheck|stats|s3-bootstrap|s3-check|reconcile]."""
from __future__ import annotations
import asyncio
import json
import logging
import os
import sys
import time
import urllib.request
_STD = set(vars(logging.LogRecord("", 0, "", 0, "", (), None))) | {"message", "asctime"}
class JsonFormatter(logging.Formatter):
"""Структурированный лог в stdout. Токены, пароли, Authorization и тела запросов не логируются."""
def format(self, record: logging.LogRecord) -> str:
data = {"ts": time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime(record.created)) + "Z",
"level": record.levelname.lower(), "logger": record.name, "msg": record.getMessage()}
data.update({k: v for k, v in vars(record).items() if k not in _STD and not k.startswith("_")})
if record.exc_info:
data["exc"] = self.formatException(record.exc_info).splitlines()[-1]
return json.dumps(data, ensure_ascii=False, default=str)
def setup_logging() -> None:
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(JsonFormatter())
logging.basicConfig(level=os.environ.get("LOG_LEVEL", "INFO").upper(), handlers=[handler], force=True)
# httpx пишет INFO на каждый запрос к S3 (URL с ключами объектов) — шум; оставляем предупреждения.
logging.getLogger("httpx").setLevel(logging.WARNING)
logging.getLogger("httpcore").setLevel(logging.WARNING)
logging.getLogger("uvicorn.access").disabled = True # свой access-log без query-строк
def serve() -> int:
import uvicorn
from .app import build_app
from .config import load
settings = load()
app = build_app(settings)
state = app.state.messenger
log = logging.getLogger("messenger.shutdown")
class DrainingServer(uvicorn.Server):
"""Graceful shutdown для работы за LB.
1-й SIGTERM/SIGINT: readiness → 503 и `Connection: close`, запросы ещё обслуживаются;
через SHUTDOWN_DRAIN_SECONDS (≥ времени обнаружения LB) uvicorn перестаёт принимать
соединения и дожидается запросов в полёте. Повторный сигнал — немедленный выход."""
drain_started = None
def handle_exit(self, sig, frame):
if self.drain_started is None and settings.shutdown_drain_seconds > 0 and not self.should_exit:
self.drain_started = time.monotonic()
state.draining = True
log.info("drain started", extra={"signal": sig, "instance_id": settings.instance_id,
"drain_seconds": settings.shutdown_drain_seconds})
return
super().handle_exit(sig, frame)
async def on_tick(self, counter):
if (self.drain_started is not None and not self.should_exit
and time.monotonic() - self.drain_started >= settings.shutdown_drain_seconds):
log.info("drain finished; closing listener", extra={"instance_id": settings.instance_id})
self.should_exit = True
return await super().on_tick(counter)
config = uvicorn.Config(app, host=settings.host, port=settings.port, log_config=None,
access_log=False, server_header=False, proxy_headers=False,
# keep-alive дольше, чем idle-пул HAProxy: соединение первым закрывает LB,
# а не реплика (иначе гонка «LB шлёт запрос в закрываемое соединение»).
timeout_keep_alive=int(os.environ.get("KEEPALIVE_SECONDS", "30")),
timeout_graceful_shutdown=10, lifespan="on",
backlog=int(os.environ.get("BACKLOG", "2048")))
server = DrainingServer(config)
server.run()
return 0 if server.started else 1
def migrate() -> int:
from .config import load
from .db import migrate_with_wait
applied = asyncio.run(migrate_with_wait(load()))
print(json.dumps({"applied": applied}))
return 0
def healthcheck() -> int:
port = os.environ.get("APP_PORT", "8080")
path = sys.argv[2] if len(sys.argv) > 2 else "/health/ready"
try:
with urllib.request.urlopen(f"http://127.0.0.1:{port}{path}", timeout=2) as resp:
return 0 if resp.status == 200 else 1
except Exception: # noqa: BLE001
return 1
def reconcile_cmd() -> int:
# stdout — только JSON-отчёт; логи в stderr
logging.getLogger().handlers[0].setStream(sys.stderr)
from .reconcile import main as reconcile_main
return reconcile_main(sys.argv[2:])
def stats() -> int:
port = os.environ.get("APP_PORT", "8080")
query = "?reset_peak=1" if "--reset-peak" in sys.argv[2:] else ""
with urllib.request.urlopen(f"http://127.0.0.1:{port}/internal/stats{query}", timeout=2) as resp:
print(resp.read().decode())
return 0
def _s3(prefix: str):
from .config import _secret
from .s3 import S3Client
endpoint = os.environ.get("S3_ENDPOINT", "http://s3:9000")
access = _secret(prefix + "ACCESS_KEY_ID", required=False)
secret = _secret(prefix + "SECRET_ACCESS_KEY", required=False)
if not access or not secret:
return None
return S3Client(endpoint, os.environ.get("S3_REGION", "us-east-1"), access, secret, timeout=10)
async def _s3_checks(bucket: str) -> dict:
"""Проверки «вне API»: bucket не отдаёт объекты/листинг анонимно, ключи API не могут создавать
бакеты и читать чужие бакеты. Возвращает словарь проверка → (ожидание, факт, ok)."""
import httpx
from .s3 import S3Error
endpoint = os.environ.get("S3_ENDPOINT", "http://s3:9000").rstrip("/")
res = {}
async with httpx.AsyncClient(timeout=5) as anon:
r = await anon.get(f"{endpoint}/{bucket}?list-type=2")
res["anonymous ListObjects"] = ("403", r.status_code, r.status_code == 403)
r = await anon.get(f"{endpoint}/{bucket}/attachments/any-object")
res["anonymous GetObject"] = ("403", r.status_code, r.status_code == 403)
r = await anon.put(f"{endpoint}/{bucket}/attachments/anon-write", content=b"x")
res["anonymous PutObject"] = ("403", r.status_code, r.status_code == 403)
r = await anon.get(f"{endpoint}/")
res["anonymous ListBuckets"] = ("403", r.status_code, r.status_code == 403)
api = _s3("S3_")
if api is not None:
try:
keys = [o async for o in api.list_objects(bucket, "attachments/", page_size=1)]
res["api ListObjects own bucket"] = ("allowed", "allowed", True)
except S3Error as exc:
res["api ListObjects own bucket"] = ("allowed", exc.code, False)
for name, coro in (("api CreateBucket", api.create_bucket("forbidden-" + bucket)),):
try:
await coro
res[name] = ("AccessDenied", "allowed", False)
except S3Error as exc:
res[name] = ("AccessDenied", exc.code, exc.status == 403)
await api.aclose()
return res
def s3_bootstrap() -> int:
"""Идемпотентный bootstrap: создать приватный bucket admin-ключом (повтор — no-op) и проверить
права. Запускается one-shot сервисом s3-init до старта реплик API."""
import time as _t
from .s3 import S3Unavailable
bucket = os.environ.get("S3_BUCKET", "messenger-attachments")
admin = _s3("S3_ADMIN_")
if admin is None:
print("S3_ADMIN_ACCESS_KEY_ID[_FILE]/S3_ADMIN_SECRET_ACCESS_KEY[_FILE] required", file=sys.stderr)
return 2
async def run():
deadline = _t.monotonic() + 60
while True:
try:
created = await admin.create_bucket(bucket)
break
except S3Unavailable:
if _t.monotonic() > deadline:
raise
await asyncio.sleep(1)
checks = await _s3_checks(bucket)
await admin.aclose()
return created, checks
created, checks = asyncio.run(run())
print(json.dumps({"bucket": bucket, "created": created, "checks": {k: list(v) for k, v in checks.items()}},
ensure_ascii=False))
return 0 if all(v[2] for v in checks.values()) else 1
def s3_check() -> int:
bucket = os.environ.get("S3_BUCKET", "messenger-attachments")
checks = asyncio.run(_s3_checks(bucket))
for k, (want, got, ok) in checks.items():
print("%-4s %-28s expected=%-12s got=%s" % ("PASS" if ok else "FAIL", k, want, got))
return 0 if all(v[2] for v in checks.values()) else 1
def main() -> int:
setup_logging()
command = sys.argv[1] if len(sys.argv) > 1 else "serve"
commands = {"serve": serve, "migrate": migrate, "healthcheck": healthcheck, "stats": stats,
"s3-bootstrap": s3_bootstrap, "s3-check": s3_check, "reconcile": reconcile_cmd}
if command not in commands:
print("usage: python -m messenger [serve|migrate|healthcheck|stats|s3-bootstrap|s3-check|reconcile]",
file=sys.stderr)
return 2
try:
return commands[command]()
except Exception as exc: # noqa: BLE001
from .config import ConfigError
if isinstance(exc, ConfigError):
logging.getLogger("messenger").error("configuration error: %s", exc)
return 2
raise
if __name__ == "__main__":
sys.exit(main())
+964
View File
@@ -0,0 +1,964 @@
"""HTTP API мессенджера (lab4): Starlette + psycopg 3 (async pool) + Redis/Valkey-кэш сессий.
Реплика stateless: всё, от чего зависит корректность (сессии, идемпотентность, данные), лежит
в PostgreSQL; Redis — только кэш. Любую реплику можно остановить или заменить."""
from __future__ import annotations
import asyncio
import base64
import binascii
import contextlib
import hashlib
import json
import os
import re
import logging
import time
import uuid
from urllib.parse import quote
from pathlib import Path
from psycopg import errors as pg_errors
from starlette.applications import Starlette
from starlette.exceptions import HTTPException
from starlette.requests import ClientDisconnect, Request
from starlette.responses import JSONResponse, Response, StreamingResponse
from starlette.routing import Route
from . import db
from .config import Settings
from .errors import ApiError, invalid, not_found, unauthorized_basic, unauthorized_bearer, unavailable
from .imagecheck import ImageRejected, sniff, validator_for
from .s3 import S3Client, S3Error, S3Unavailable
from .security import PasswordHasher, looks_like_token, new_token, token_hash
from .sessions import Principal, SessionCache
from .validation import (USERNAME_RE, decode_cursor, encode_cursor, parse_json_object, parse_limit,
parse_uuid, single_param, text_field)
log = logging.getLogger("messenger.http")
# --------------------------------------------------------------------------------------------
# Ответы и обвязка
# --------------------------------------------------------------------------------------------
def request_id(request: Request) -> str:
rid = getattr(request.state, "request_id", None)
if not rid:
rid = uuid.uuid4().hex
request.state.request_id = rid
return rid
def json_response(request: Request, payload, status: int = 200, headers: dict | None = None) -> JSONResponse:
h = {"X-Request-Id": request_id(request), "Cache-Control": "no-store"}
h.update(headers or {})
return JSONResponse(payload, status_code=status, headers=h)
def error_response(request: Request, err: ApiError) -> JSONResponse:
rid = request_id(request)
body = {"error": {"code": err.public_code, "message": err.message, "request_id": rid}}
return json_response(request, body, err.status, err.headers)
class RequestContextMiddleware:
"""Чистый ASGI middleware: X-Request-Id в каждом ответе (включая 404/405 роутера) и access-log
без query-строки, заголовков и тела."""
def __init__(self, app, instance_id: str = "api", state=None):
self.app = app
self.instance_id = instance_id.encode()
self.state = state
async def __call__(self, scope, receive, send):
if scope["type"] != "http":
return await self.app(scope, receive, send)
rid = uuid.uuid4().hex
scope.setdefault("state", {})["request_id"] = rid
started = time.monotonic()
status_holder = {}
async def send_wrapper(message):
if message["type"] == "http.response.start":
status_holder["status"] = message["status"]
headers = list(message.get("headers", []))
if not any(k.lower() == b"x-request-id" for k, _ in headers):
headers.append((b"x-request-id", rid.encode()))
headers.append((b"x-instance-id", self.instance_id))
if self.state is not None and self.state.draining:
# Во время drain просим клиента/LB не переиспользовать соединение с этой репликой.
headers.append((b"connection", b"close"))
message["headers"] = headers
await send(message)
try:
await self.app(scope, receive, send_wrapper)
finally:
if self.state is not None:
self.state.stats["requests"] += 1
log.info("request", extra={"request_id": rid, "method": scope.get("method"),
"path": scope.get("path"), "status": status_holder.get("status"),
"duration_ms": round((time.monotonic() - started) * 1000, 2)})
def endpoint(handler, timeout_setting: str = "request_timeout_seconds"):
"""Единая обработка ошибок и общий таймаут запроса (для upload — UPLOAD_TIMEOUT_SECONDS)."""
async def wrapper(request: Request):
state: AppState = request.app.state.messenger
try:
async with asyncio.timeout(getattr(state.settings, timeout_setting)):
return await handler(request, state)
except ApiError as err:
return error_response(request, err)
except Exception as exc: # noqa: BLE001
if db.is_unavailable(exc) or isinstance(exc, (TimeoutError, S3Unavailable)):
log.warning("dependency unavailable", extra={"request_id": request_id(request),
"error": type(exc).__name__})
return error_response(request, unavailable())
log.exception("unhandled error", extra={"request_id": request_id(request)})
return error_response(request, ApiError("internal_error"))
wrapper.__name__ = handler.__name__
return wrapper
async def read_body(request: Request, limit: int) -> bytes:
declared = request.headers.get("content-length")
if declared is not None:
if not declared.isdigit():
raise invalid("Некорректный Content-Length")
if int(declared) > limit:
raise ApiError("payload_too_large")
chunks, size = [], 0
async for chunk in request.stream():
size += len(chunk)
if size > limit:
raise ApiError("payload_too_large")
chunks.append(chunk)
return b"".join(chunks)
async def read_json(request: Request, state: "AppState", allowed: set[str], required: set[str]) -> dict:
ctype = request.headers.get("content-type", "").split(";")[0].strip().lower()
body = await read_body(request, state.settings.max_body_bytes)
if ctype != "application/json":
raise invalid("Ожидается Content-Type: application/json")
return parse_json_object(body, allowed, required)
def user_json(row) -> dict:
return {"id": str(row["id"]), "username": row["username"], "display_name": row["display_name"],
"created_at": db.iso(row["created_at"])}
def chat_json(row) -> dict:
return {"id": str(row["id"]), "title": row["title"],
"member_ids": [str(m) for m in row["member_ids"]], "created_at": db.iso(row["created_at"])}
def message_json(row) -> dict:
return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]),
"text": row["text"], "created_at": db.iso(row["created_at"]),
"attachment_ids": [str(a) for a in (row.get("attachment_ids") or [])]}
def attachment_json(row) -> dict:
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": row["status"], "variants": [], "error_code": None,
"created_at": db.iso(row["created_at"]), "updated_at": db.iso(row["updated_at"])}
# --------------------------------------------------------------------------------------------
# Состояние приложения и аутентификация
# --------------------------------------------------------------------------------------------
class AppState:
def __init__(self, settings: Settings):
self.settings = settings
self.pool = db.make_pool(settings)
self.cache = SessionCache(settings)
self.hasher = PasswordHasher(settings.scrypt_log2_n, settings.scrypt_r, settings.scrypt_p,
settings.kdf_concurrency)
self.ready = False # схема проверена, пул открыт
self.draining = False # получен SIGTERM: readiness = 503, LB выводит реплику
self.stop = asyncio.Event()
self.tasks: list[asyncio.Task] = []
self.stats = {"requests": 0, "inflight": 0, "idempotent_replays": 0, "idempotency_conflicts": 0,
"uploads_ok": 0, "uploads_rejected": 0, "uploads_failed": 0, "compensations": 0,
"janitor_removed": 0}
self.s3 = None
if settings.s3_endpoint and settings.s3_access_key and settings.s3_secret_key:
self.s3 = S3Client(settings.s3_endpoint, settings.s3_region, settings.s3_access_key,
settings.s3_secret_key, timeout=settings.s3_timeout_seconds)
# Одновременных загрузок на реплику не больше UPLOAD_CONCURRENCY (RAM и соединения к S3 ограничены).
self.upload_slots = asyncio.Semaphore(settings.upload_concurrency)
async def authenticate(request: Request, state: AppState) -> Principal:
"""Только Authorization: Bearer <opaque>. X-User-Id и Basic игнорируются/отклоняются."""
header = request.headers.get("authorization", "")
scheme, _, token = header.partition(" ")
token = token.strip()
if scheme.lower() != "bearer" or not looks_like_token(token):
raise unauthorized_bearer()
th = token_hash(token)
principal = await state.cache.get(th)
if principal is not None:
return principal
async with state.pool.connection() as conn:
row = await (await 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.revoked_at IS NULL AND s.expires_at > clock_timestamp()",
(th,))).fetchone()
if row is None:
raise unauthorized_bearer()
principal = Principal(user=user_json(row), expires_at=row["expires_at"].timestamp(), token_hash=th)
await state.cache.put(principal)
return principal
def parse_basic(header: str) -> tuple[str, str]:
scheme, _, value = header.partition(" ")
if scheme.lower() != "basic" or not value.strip():
raise unauthorized_basic()
try:
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
except (binascii.Error, ValueError, UnicodeDecodeError):
raise unauthorized_basic() from None
username, sep, password = decoded.partition(":") # двоеточие допустимо только в пароле
if not sep or not username.isascii() or not USERNAME_RE.fullmatch(username) or not 12 <= len(password) <= 128:
raise unauthorized_basic()
return username, password
# --------------------------------------------------------------------------------------------
# Handlers
# --------------------------------------------------------------------------------------------
@endpoint
async def live(request: Request, state: AppState):
return json_response(request, {"status": "ok"})
@endpoint
async def ready(request: Request, state: AppState):
# Критичная зависимость синхронного пути — только PostgreSQL. Redis — кэш: при его потере
# API продолжает работу через источник истины, поэтому readiness от него не зависит.
# S3 тоже не входит в readiness: без него недоступны только вложения (503), текстовые сообщения
# работают — иначе отказ S3 вывел бы из LB все реплики и уронил весь мессенджер.
if not state.ready or state.draining:
raise unavailable()
try:
async with asyncio.timeout(1.5):
async with state.pool.connection() as conn:
await conn.execute("SELECT 1")
except Exception: # noqa: BLE001
raise unavailable() from None
return json_response(request, {"status": "ok"})
@endpoint
async def internal_stats(request: Request, state: AppState):
"""Только для исследования/диагностики изнутри контейнера; LB отдаёт 404 на /internal/*."""
if request.client is None or request.client.host not in {"127.0.0.1", "::1"}:
raise not_found()
pool = state.pool.get_stats()
if request.query_params.get("reset_peak") == "1":
# Сброс VmHWM (пик RSS) — для измерения пика памяти в конкретном эксперименте.
with contextlib.suppress(OSError):
with open("/proc/self/clear_refs", "w") as fh:
fh.write("5")
return json_response(request, {"instance_id": state.settings.instance_id,
"version": os.environ.get("APP_VERSION", "dev"), "ready": state.ready,
"draining": state.draining, "app": state.stats, "memory": _proc_memory(),
"uploads_in_flight": state.settings.upload_concurrency - state.upload_slots._value,
"cache": state.cache.stats, "pool": pool})
def _proc_memory() -> dict:
out = {}
try:
with open("/proc/self/status") as fh:
for line in fh:
if line.startswith(("VmRSS:", "VmHWM:")):
name, value = line.split(":", 1)
out[{"VmRSS": "rss_kib", "VmHWM": "peak_rss_kib"}[name]] = int(value.split()[0])
except OSError:
pass
return out
@endpoint
async def create_user(request: Request, state: AppState):
data = await read_json(request, state, {"username", "display_name", "password"},
{"username", "display_name", "password"})
username = data["username"]
if not isinstance(username, str) or not USERNAME_RE.fullmatch(username):
raise invalid("username должен соответствовать [a-z0-9_]{3,32}")
display_name = text_field(data, "display_name", 1, 100)
password = text_field(data, "password", 12, 128)
async with state.pool.connection() as conn:
taken = await (await conn.execute("SELECT 1 FROM users WHERE username = %s", (username,))).fetchone()
if taken:
raise ApiError("conflict", "username уже занят")
password_hash = await state.hasher.hash(password)
try:
async with state.pool.connection() as conn:
row = await (await conn.execute(
"INSERT INTO users (username, display_name, password_hash) VALUES (%s, %s, %s)"
" RETURNING id, username, display_name, created_at",
(username, display_name, password_hash))).fetchone()
except pg_errors.UniqueViolation:
# Гонка регистрации: проверку выше прошли оба запроса, уникальный индекс пропустил один.
log.info("registration race resolved by unique constraint", extra={"request_id": request_id(request)})
raise ApiError("conflict", "username уже занят") from None
return json_response(request, user_json(row), 201)
@endpoint
async def me(request: Request, state: AppState):
principal = await authenticate(request, state)
return json_response(request, principal.user)
@endpoint
async def create_session(request: Request, state: AppState):
username, password = parse_basic(request.headers.get("authorization", ""))
body = await read_body(request, 1024)
if body:
raise invalid("POST /auth/sessions не принимает тело")
async with state.pool.connection() as conn:
row = await (await conn.execute(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
(username,))).fetchone()
ok = await state.hasher.verify(password, row["password_hash"] if row else None)
if not ok:
raise unauthorized_basic()
token = new_token()
th = token_hash(token)
async with state.pool.connection() as conn:
srow = await (await conn.execute(
"INSERT INTO sessions (token_hash, user_id, expires_at)"
" VALUES (%s, %s, clock_timestamp() + make_interval(secs => %s)) RETURNING expires_at",
(th, row["id"], state.settings.session_ttl_seconds))).fetchone()
user = user_json(row)
await state.cache.put(Principal(user=user, expires_at=srow["expires_at"].timestamp(), token_hash=th))
return json_response(request, {"token": token, "token_type": "Bearer",
"expires_at": db.iso(srow["expires_at"]), "user": user}, 201)
@endpoint
async def delete_session(request: Request, state: AppState):
principal = await authenticate(request, state)
th = principal.token_hash
async with state.pool.connection() as conn:
async with conn.transaction():
revoked = await (await conn.execute(
"UPDATE sessions SET revoked_at = clock_timestamp()"
" WHERE token_hash = %s AND revoked_at IS NULL RETURNING 1", (th,))).fetchone()
if revoked is None:
raise unauthorized_bearer()
if state.cache.enabled:
await conn.execute(
"INSERT INTO session_cache_invalidations (token_hash) VALUES (%s) ON CONFLICT DO NOTHING",
(th,))
# COMMIT в PostgreSQL уже сделал отзыв окончательным; Redis лишь догоняет источник истины.
if state.cache.enabled and await state.cache.invalidate(th):
with contextlib.suppress(Exception):
async with state.pool.connection() as conn:
await conn.execute("DELETE FROM session_cache_invalidations WHERE token_hash = %s", (th,))
return Response(status_code=204, headers={"X-Request-Id": request_id(request)})
@endpoint
async def create_chat(request: Request, state: AppState):
principal = await authenticate(request, state)
data = await read_json(request, state, {"title", "member_ids"}, {"title", "member_ids"})
title = text_field(data, "title", 1, 100)
raw_members = data["member_ids"]
if not isinstance(raw_members, list) or not 1 <= len(raw_members) <= 100:
raise invalid("member_ids: массив из 1–100 UUID")
members = [parse_uuid(m, "member_id") for m in raw_members]
if len(set(members)) != len(members):
raise invalid("member_ids содержит дубликаты")
caller = uuid.UUID(principal.user["id"])
if caller not in members:
raise invalid("member_ids должен содержать создателя чата")
async with state.pool.connection() as conn:
try:
async with conn.transaction(): # атомарно: чат и весь состав или ничего
chat = await (await conn.execute(
"INSERT INTO chats (title, created_by) VALUES (%s, %s) RETURNING id, title, created_at",
(title, caller))).fetchone()
await conn.execute(
"INSERT INTO chat_members (chat_id, user_id, position)"
" SELECT %s, m.user_id, m.ord - 1 FROM unnest(%s::uuid[]) WITH ORDINALITY AS m(user_id, ord)",
(chat["id"], members))
except pg_errors.ForeignKeyViolation:
raise invalid("member_ids содержит неизвестного пользователя") from None
chat["member_ids"] = members
return json_response(request, chat_json(chat), 201)
_CHAT_LIST_SQL = (
"SELECT c.id, c.title, c.created_at,"
" (SELECT array_agg(x.user_id ORDER BY x.position) FROM chat_members x WHERE x.chat_id = c.id) AS member_ids"
" FROM chat_members m JOIN chats c ON c.id = m.chat_id"
" WHERE m.user_id = %s {after}"
" ORDER BY c.created_at, c.id LIMIT %s")
@endpoint
async def list_chats(request: Request, state: AppState):
principal = await authenticate(request, state)
caller = uuid.UUID(principal.user["id"])
limit = parse_limit(request.query_params)
cursor = single_param(request.query_params, "cursor")
async with state.pool.connection() as conn:
if cursor is not None:
ts, last_id = decode_cursor(cursor, "chats", caller)
rows = await (await conn.execute(_CHAT_LIST_SQL.format(after="AND (c.created_at, c.id) > (%s, %s)"),
(caller, ts, last_id, limit + 1))).fetchall()
else:
rows = await (await conn.execute(_CHAT_LIST_SQL.format(after=""), (caller, limit + 1))).fetchall()
items = rows[:limit]
next_cursor = (encode_cursor("chats", caller, items[-1]["created_at"], items[-1]["id"])
if len(rows) > limit else None)
return json_response(request, {"items": [chat_json(r) for r in items], "next_cursor": next_cursor})
@endpoint
async def get_chat(request: Request, state: AppState):
principal = await authenticate(request, state)
chat_id = parse_uuid(request.path_params["chat_id"], "chat_id")
async with state.pool.connection() as conn:
row = await (await conn.execute(
"SELECT c.id, c.title, c.created_at, array_agg(m.user_id ORDER BY m.position) AS member_ids"
" FROM chats c JOIN chat_members m ON m.chat_id = c.id"
" WHERE c.id = %s AND EXISTS (SELECT 1 FROM chat_members a WHERE a.chat_id = c.id AND a.user_id = %s)"
" GROUP BY c.id", (chat_id, uuid.UUID(principal.user["id"])))).fetchone()
if row is None:
raise not_found() # нет или чужой — одинаковый ответ
return json_response(request, chat_json(row))
async def _is_member(conn, chat_id: uuid.UUID, user_id: uuid.UUID) -> bool:
row = await (await conn.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id, user_id))).fetchone()
return row is not None
# Вложения сообщения в порядке attachment_ids запроса (m — алиас messages).
_ATTACHMENT_IDS = (" (SELECT coalesce(array_agg(ma.attachment_id ORDER BY ma.position), '{}')"
" FROM message_attachments ma WHERE ma.message_id = m.id) AS attachment_ids")
IDEMPOTENCY_KEY_RE = re.compile(r"[A-Za-z0-9._:-]{1,128}")
def idempotency_key(request: Request) -> str:
values = request.headers.getlist("idempotency-key")
if len(values) != 1 or not IDEMPOTENCY_KEY_RE.fullmatch(values[0]):
raise invalid("Требуется заголовок Idempotency-Key: [A-Za-z0-9._:-]{1,128}")
return values[0]
def request_fingerprint(body: dict) -> bytes:
"""SHA-256 канонического JSON: порядок ключей и пробелы не влияют на равенство запросов."""
canonical = json.dumps(body, sort_keys=True, ensure_ascii=False, separators=(",", ":"))
return hashlib.sha256(canonical.encode("utf-8")).digest()
class _Replay(Exception):
"""Ключ уже занят: откатить свою вставку и прочитать сохранённый результат."""
@endpoint
async def create_message(request: Request, state: AppState):
principal = await authenticate(request, state)
chat_id = parse_uuid(request.path_params["chat_id"], "chat_id")
sender = uuid.UUID(principal.user["id"])
try:
key = idempotency_key(request)
data = await read_json(request, state, {"text", "attachment_ids"}, {"text"})
raw_ids = data.get("attachment_ids", [])
if not isinstance(raw_ids, list) or len(raw_ids) > 10:
raise invalid("attachment_ids: массив из 0–10 UUID")
att_ids = [parse_uuid(x, "attachment_id") for x in raw_ids]
if len(set(att_ids)) != len(att_ids):
raise invalid("attachment_ids содержит дубликаты")
# С вложениями текст может быть пустым; без вложений — 1–4000 непробельных символов.
text = text_field(data, "text", 0 if att_ids else 1, 4000)
except ApiError as err:
if err.status == 400:
# Посторонний не должен по 400/404 узнавать о существовании чата.
async with state.pool.connection() as conn:
if not await _is_member(conn, chat_id, sender):
raise not_found() from None
raise
# Отсутствующий attachment_ids и [] семантически равны (контракт), порядок ID значим.
fingerprint = request_fingerprint({"text": text, "attachment_ids": [str(a) for a in att_ids]})
ttl = state.settings.idempotency_ttl_seconds
async with state.pool.connection() as conn:
try:
# Одна транзакция: сообщение и запись ключа фиксируются вместе или не фиксируются вовсе.
# Конкурентный INSERT того же ключа (любая реплика) ждёт COMMIT/ROLLBACK первого на
# уникальном индексе: после COMMIT получает конфликт, после ROLLBACK — проходит сам.
async with conn.transaction():
await conn.execute(
"DELETE FROM idempotency_keys WHERE user_id = %s AND chat_id = %s AND key = %s"
" AND created_at < clock_timestamp() - make_interval(secs => %s)",
(sender, chat_id, key, ttl))
row = await (await conn.execute(
"INSERT INTO messages (chat_id, sender_id, text)"
" SELECT %(c)s, %(u)s, %(t)s"
" WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = %(c)s AND user_id = %(u)s)"
" RETURNING id, chat_id, sender_id, text, created_at",
{"c": chat_id, "u": sender, "t": text})).fetchone()
if row is None:
raise not_found() # откат: ошибка доступа не фиксируется как результат ключа
if att_ids:
# Все вложения обязаны принадлежать ЭТОМУ чату; чужое/неизвестное — 404 (откат).
# FOR KEY SHARE: параллельный reconciler не удалит строку между проверкой и INSERT.
found = await (await conn.execute(
"SELECT count(*) AS n FROM (SELECT 1 FROM attachments WHERE id = ANY(%s) AND chat_id = %s"
" FOR KEY SHARE) s", (att_ids, chat_id))).fetchone()
if found["n"] != len(att_ids):
raise not_found()
await conn.execute(
"INSERT INTO message_attachments (message_id, attachment_id, position)"
" SELECT %s, a.id, a.ord - 1 FROM unnest(%s::uuid[]) WITH ORDINALITY AS a(id, ord)",
(row["id"], att_ids))
row["attachment_ids"] = att_ids
claimed = await (await conn.execute(
"INSERT INTO idempotency_keys (user_id, chat_id, key, request_hash, message_id)"
" VALUES (%s, %s, %s, %s, %s) ON CONFLICT DO NOTHING RETURNING 1",
(sender, chat_id, key, fingerprint, row["id"]))).fetchone()
if claimed is None:
raise _Replay()
except _Replay:
# Повтор: снова проверены сессия (authenticate) и доступ (членство), затем — сохранённый ответ.
stored = await (await conn.execute(
"SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at," + _ATTACHMENT_IDS +
" FROM idempotency_keys k JOIN messages m ON m.id = k.message_id"
" WHERE k.user_id = %s AND k.chat_id = %s AND k.key = %s"
" AND EXISTS (SELECT 1 FROM chat_members a WHERE a.chat_id = k.chat_id AND a.user_id = k.user_id)",
(sender, chat_id, key))).fetchone()
if stored is None:
raise not_found() from None
if bytes(stored["request_hash"]) != fingerprint:
state.stats["idempotency_conflicts"] += 1
raise ApiError("conflict", "Idempotency-Key уже использован с другим запросом") from None
state.stats["idempotent_replays"] += 1
return json_response(request, message_json(stored), 201, {"Idempotent-Replayed": "true"})
return json_response(request, message_json(row), 201)
_HISTORY_SQL = (
"SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at," + "{atts}" + " FROM messages m"
" WHERE m.chat_id = %s {after} ORDER BY m.created_at, m.id LIMIT %s")
@endpoint
async def list_messages(request: Request, state: AppState):
principal = await authenticate(request, state)
chat_id = parse_uuid(request.path_params["chat_id"], "chat_id")
async with state.pool.connection() as conn:
if not await _is_member(conn, chat_id, uuid.UUID(principal.user["id"])):
raise not_found()
limit = parse_limit(request.query_params)
cursor = single_param(request.query_params, "cursor")
if cursor is not None:
ts, last_id = decode_cursor(cursor, "messages", chat_id)
rows = await (await conn.execute(_HISTORY_SQL.format(atts=_ATTACHMENT_IDS, after="AND (m.created_at, m.id) > (%s, %s)"),
(chat_id, ts, last_id, limit + 1))).fetchall()
else:
rows = await (await conn.execute(_HISTORY_SQL.format(atts=_ATTACHMENT_IDS, after=""), (chat_id, limit + 1))).fetchall()
items = rows[:limit]
next_cursor = (encode_cursor("messages", chat_id, items[-1]["created_at"], items[-1]["id"])
if len(rows) > limit else None)
return json_response(request, {"items": [message_json(r) for r in items], "next_cursor": next_cursor})
# --------------------------------------------------------------------------------------------
# Вложения (lab4)
# --------------------------------------------------------------------------------------------
# / \ NUL, управляющие C0/C1, bidi-override (U+202A–202E, U+2066–2069, U+200E/F: «evil\u202egnp.exe»),
# разделители строк/абзацев U+2028/2029, BOM.
_BAD_FILENAME = re.compile(r"[/\\\x00-\x1f\x7f-\x9f\u200e\u200f\u202a-\u202e\u2066-\u2069\u2028\u2029\ufeff]")
_IMAGE_TYPES = ("image/png", "image/jpeg")
_VARIANTS = ("original", "thumbnail", "crop", "optimized")
class _ClientGone(Exception):
"""Клиент оборвал загрузку (меньше байт, чем в Content-Length, или разрыв соединения)."""
def _filename(request: Request) -> str:
name = single_param(request.query_params, "filename")
if name is None or not 1 <= len(name) <= 255 or not name.strip() or _BAD_FILENAME.search(name) \
or not name.strip(". "): # «.», «..», «...» — не имена файлов
raise invalid("filename: 1–255 символов, без / \\ NUL и управляющих символов")
try:
name.encode("utf-8")
except UnicodeEncodeError:
raise invalid("filename: некорректный Unicode") from None
return name
async def _drain(it, limit: int) -> None:
"""Дочитать (и выбросить) остаток тела, не больше limit байт и 10 с: клиент получит ответ,
а не разрыв соединения посреди отправки. Память не растёт — куски сразу отбрасываются."""
read = 0
try:
async with asyncio.timeout(10):
async for chunk in it:
read += len(chunk)
if read > limit:
return
except (Exception, asyncio.CancelledError): # noqa: BLE001
return
async def _compensate(state: AppState, key: str) -> None:
"""Немедленная компенсация неуспешной загрузки: удалить объект (если успел появиться) и намерение.
Если S3 недоступен — намерение остаётся, объект уберёт фоновая очистка после grace period."""
state.stats["compensations"] += 1
try:
await state.s3.delete_object(state.settings.s3_bucket, key)
except (S3Error, S3Unavailable):
log.warning("compensation deferred to janitor", extra={"object_key": key})
return
with contextlib.suppress(Exception):
async with state.pool.connection() as conn:
await conn.execute("DELETE FROM upload_intents WHERE object_key = %s", (key,))
async def upload_attachment(request: Request, state: AppState):
principal = await authenticate(request, state)
chat_id = parse_uuid(request.path_params["chat_id"], "chat_id")
owner = uuid.UUID(principal.user["id"])
async with state.pool.connection() as conn:
if not await _is_member(conn, chat_id, owner):
raise not_found() # до чтения тела: посторонний не заставит читать 10 МиБ
filename = _filename(request)
declared = request.headers.get("content-type", "").split(";")[0].strip().lower()
if declared not in _IMAGE_TYPES:
raise ApiError("unsupported_media_type", "Принимаются только image/png и image/jpeg")
length_header = request.headers.get("content-length")
if length_header is None:
raise invalid("Требуется Content-Length (сырые байты одного файла)")
if not length_header.isdigit():
raise invalid("Некорректный Content-Length")
length = int(length_header)
if length > state.settings.max_upload_bytes:
raise ApiError("payload_too_large", "Файл больше %d байт" % state.settings.max_upload_bytes)
if length == 0:
raise ApiError("unsupported_media_type", "Пустое тело — не изображение")
if state.s3 is None:
raise unavailable()
try:
await asyncio.wait_for(state.upload_slots.acquire(), timeout=5)
except asyncio.TimeoutError:
raise unavailable() from None
try:
return await _store_upload(request, state, chat_id, owner, filename, declared, length)
finally:
state.upload_slots.release()
async def _store_upload(request, state, chat_id, owner, filename, declared, length):
s = state.settings
att_id = uuid.uuid4()
key = "attachments/" + att_id.hex # ключ назначает сервер; filename в нём не участвует
# 1) Намерение фиксируется ДО записи в S3 (отдельная транзакция).
async with state.pool.connection() as conn:
await conn.execute("INSERT INTO upload_intents (object_key, attachment_id, chat_id, owner_id)"
" VALUES (%s, %s, %s, %s)", (key, att_id, chat_id, owner))
it = request.stream().__aiter__()
sha, received = hashlib.sha256(), 0
dims = {}
try:
head = b""
try:
while len(head) < 16:
head += await it.__anext__()
except StopAsyncIteration:
pass
detected = sniff(head)
if detected is None:
raise ImageRejected("invalid", "содержимое не PNG/JPEG")
if detected != declared:
raise ImageRejected("invalid", "Content-Type не совпадает с содержимым (%s)" % detected)
validator = validator_for(detected, s.max_image_pixels)
async def body():
nonlocal received
pending = [head]
while True:
if pending:
piece = pending.pop()
else:
try:
piece = await it.__anext__()
except StopAsyncIteration:
break
except ClientDisconnect:
raise _ClientGone() from None
received += len(piece)
if received > length:
raise ApiError("payload_too_large", "Тело длиннее Content-Length")
validator.feed(piece) # 413/415 — до того, как S3 получит весь объект
sha.update(piece)
yield piece
if received != length:
raise _ClientGone()
dims["wh"] = validator.finish() # ошибка здесь обрывает PUT: объект не фиксируется
# 2) Потоковый PUT: в RAM держится только текущий кусок (≈64 КиБ), не весь файл.
await state.s3.put_object_stream(s.s3_bucket, key, body(), length, detected)
if s.fault_inject == "crash_after_s3_put":
log.error("FAULT INJECTION: process exits between S3 PUT and DB COMMIT", extra={"object_key": key})
os._exit(137)
# 3) Метаданные и снятие намерения — одной транзакцией. COMMIT = файл и метаданные сохранены.
width, height = dims["wh"]
async with state.pool.connection() as conn:
async with conn.transaction():
row = await (await conn.execute(
"INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256,"
" width, height, object_key) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s) RETURNING *",
(att_id, chat_id, owner, filename, detected, received, sha.hexdigest(), width, height, key))).fetchone()
await conn.execute("DELETE FROM upload_intents WHERE object_key = %s", (key,))
except ImageRejected as exc:
state.stats["uploads_rejected"] += 1
await _drain(it, s.max_upload_bytes + 65536)
await _compensate(state, key)
if exc.kind == "too_large":
raise ApiError("payload_too_large", "Слишком много пикселей: максимум %d" % s.max_image_pixels) from None
raise ApiError("unsupported_media_type", "Файл не является корректным PNG/JPEG: " + str(exc)) from None
except ApiError:
state.stats["uploads_rejected"] += 1
await _drain(it, s.max_upload_bytes + 65536)
await _compensate(state, key)
raise
except (_ClientGone, ClientDisconnect):
state.stats["uploads_failed"] += 1
await _compensate(state, key)
raise invalid("Загрузка прервана: получено %d из %d байт" % (received, length)) from None
except BaseException:
# S3/БД недоступны, таймаут, отмена: компенсация (или отложенная — через намерение).
state.stats["uploads_failed"] += 1
with contextlib.suppress(Exception):
await asyncio.shield(_compensate(state, key))
raise
state.stats["uploads_ok"] += 1
return json_response(request, attachment_json(row), 201)
_ATTACHMENT_SQL = ("SELECT a.* FROM attachments a WHERE a.id = %s AND EXISTS (SELECT 1 FROM chat_members m"
" WHERE m.chat_id = a.chat_id AND m.user_id = %s)")
@endpoint
async def get_attachment(request: Request, state: AppState):
principal = await authenticate(request, state)
att_id = parse_uuid(request.path_params["attachment_id"], "attachment_id")
async with state.pool.connection() as conn:
row = await (await conn.execute(_ATTACHMENT_SQL, (att_id, uuid.UUID(principal.user["id"])))).fetchone()
if row is None:
raise not_found()
return json_response(request, attachment_json(row))
async def download_attachment(request: Request, state: AppState):
principal = await authenticate(request, state)
att_id = parse_uuid(request.path_params["attachment_id"], "attachment_id")
variant = single_param(request.query_params, "variant") or "original"
if variant not in _VARIANTS:
raise invalid("variant: original")
async with state.pool.connection() as conn:
row = await (await conn.execute(_ATTACHMENT_SQL, (att_id, uuid.UUID(principal.user["id"])))).fetchone()
if row is None:
raise not_found()
if variant != "original":
raise not_found() # lab4: вариантов нет; отсутствующий вариант ready-объекта — 404
if state.s3 is None:
raise unavailable()
try:
resp = await state.s3.get_object_stream(state.settings.s3_bucket, row["object_key"])
except S3Error as exc:
if exc.status == 404:
log.error("attachment object missing in S3", extra={"attachment_id": str(att_id)})
raise ApiError("internal_error", "Содержимое вложения утрачено") from None
raise unavailable() from None
async def stream():
try:
async for chunk in resp.aiter_bytes(65536):
yield chunk
finally:
await resp.aclose()
return StreamingResponse(stream(), media_type=row["content_type"], headers={
"Content-Length": str(row["size_bytes"]), "ETag": '"%s"' % row["sha256"],
"Cache-Control": "private, no-store", "X-Content-Type-Options": "nosniff",
"Content-Disposition": "inline; filename*=UTF-8''" + quote(row["filename"], safe=""),
"X-Request-Id": request_id(request)})
JANITOR_LOCK_ID = 2026_0404
def intent_grace_seconds(settings) -> float:
"""Intent нельзя считать брошенным, пока загрузка ещё может законно идти (UPLOAD_TIMEOUT_SECONDS):
иначе очистка удалила бы объект между S3 PUT и COMMIT живого запроса."""
return max(float(settings.upload_grace_seconds), settings.upload_timeout_seconds + 5)
async def upload_janitor(state: AppState) -> None:
"""Фоновая очистка намерений старше UPLOAD_GRACE_SECONDS: процесс упал между S3 PUT и COMMIT или
во время загрузки. Объект по ключу удаляется (если метаданных нет), намерение снимается.
Одновременно работает одна реплика (pg_try_advisory_lock); повтор безопасен (идемпотентно)."""
while not state.stop.is_set():
try:
if state.s3 is not None and state.ready:
async with state.pool.connection() as conn:
got = await (await conn.execute("SELECT pg_try_advisory_lock(%s) AS ok", (JANITOR_LOCK_ID,))).fetchone()
if got["ok"]:
try:
removed = await janitor_pass(state, conn)
if removed:
log.info("janitor removed stale uploads", extra={"count": removed})
finally:
await conn.execute("SELECT pg_advisory_unlock(%s)", (JANITOR_LOCK_ID,))
except Exception as exc: # noqa: BLE001
log.warning("janitor pass failed", extra={"error": type(exc).__name__})
with contextlib.suppress(asyncio.TimeoutError):
await asyncio.wait_for(state.stop.wait(), timeout=state.settings.janitor_interval_seconds)
async def janitor_pass(state: AppState, conn) -> int:
rows = await (await conn.execute(
"SELECT i.object_key, EXISTS (SELECT 1 FROM attachments a WHERE a.object_key = i.object_key) AS committed"
" FROM upload_intents i WHERE i.created_at < clock_timestamp() - make_interval(secs => %s)"
" ORDER BY i.created_at LIMIT 200", (intent_grace_seconds(state.settings),))).fetchall()
removed = 0
for r in rows:
if not r["committed"]:
await state.s3.delete_object(state.settings.s3_bucket, r["object_key"]) # 204 и при отсутствии
removed += 1
await conn.execute("DELETE FROM upload_intents WHERE object_key = %s", (r["object_key"],))
state.stats["janitor_removed"] += removed
return removed
# --------------------------------------------------------------------------------------------
# Фоновые задачи и сборка приложения
# --------------------------------------------------------------------------------------------
async def wait_for_schema(state: AppState) -> None:
"""Реплика не мигрирует схему сама (это делает one-shot сервис migrate) и не становится ready,
пока в БД не применены все миграции, которые знает этот код."""
delay = 0.5
while not state.stop.is_set():
try:
ok, missing = await db.schema_status(state.pool)
if ok:
state.ready = True
log.info("schema compatible; replica ready", extra={"instance_id": state.settings.instance_id})
return
log.warning("schema is behind this code; waiting for migrate", extra={"missing": missing})
except Exception as exc: # noqa: BLE001 — БД ещё недоступна или нет schema_migrations
log.warning("schema check failed; retrying", extra={"error": type(exc).__name__})
with contextlib.suppress(asyncio.TimeoutError):
await asyncio.wait_for(state.stop.wait(), timeout=delay)
delay = min(delay * 2, 5)
async def expired_sessions_cleanup(state: AppState) -> None:
"""Удаляет сессии, истёкшие более суток назад, пачками (не держит долгих блокировок)."""
while not state.stop.is_set():
with contextlib.suppress(Exception):
async with state.pool.connection() as conn:
await conn.execute(
"DELETE FROM sessions WHERE token_hash IN (SELECT token_hash FROM sessions"
" WHERE expires_at < clock_timestamp() - interval '1 day' LIMIT 1000)")
await conn.execute(
"DELETE FROM idempotency_keys WHERE ctid IN (SELECT ctid FROM idempotency_keys"
" WHERE created_at < clock_timestamp() - make_interval(secs => %s) LIMIT 5000)",
(state.settings.idempotency_ttl_seconds,))
with contextlib.suppress(asyncio.TimeoutError):
await asyncio.wait_for(state.stop.wait(), timeout=300)
def build_app(settings: Settings) -> Starlette:
state = AppState(settings)
@contextlib.asynccontextmanager
async def lifespan(app: Starlette):
if settings.migrate_on_start:
applied = await db.migrate_with_wait(settings)
log.info("migrations checked", extra={"applied": applied})
await state.pool.open(wait=False)
with contextlib.suppress(OSError):
Path(settings.instance_id_file).write_text(settings.instance_id + "\n")
state.tasks.append(asyncio.create_task(wait_for_schema(state)))
if state.cache.enabled:
state.tasks.append(asyncio.create_task(state.cache.maintenance_loop(state.pool, state.stop)))
state.tasks.append(asyncio.create_task(expired_sessions_cleanup(state)))
state.tasks.append(asyncio.create_task(upload_janitor(state)))
log.info("api started", extra={"instance_id": settings.instance_id, "version": os.environ.get("APP_VERSION", "dev"),
"cache": state.cache.enabled,
"session_ttl_seconds": settings.session_ttl_seconds})
try:
yield
finally:
state.ready = False
state.stop.set()
for task in state.tasks:
task.cancel()
await asyncio.gather(*state.tasks, return_exceptions=True)
await state.cache.close()
if state.s3 is not None:
await state.s3.aclose()
await state.pool.close()
async def http_exception(request: Request, exc: HTTPException):
if exc.status_code == 405:
err = ApiError("method_not_allowed", "Метод не поддерживается", headers=dict(exc.headers or {}))
elif exc.status_code == 404:
err = ApiError("not_found")
else:
err = ApiError("invalid_request")
return error_response(request, err)
async def server_error(request: Request, exc: Exception):
return error_response(request, ApiError("internal_error"))
routes = [
Route("/health/live", live, methods=["GET"]),
Route("/health/ready", ready, methods=["GET"]),
Route("/internal/stats", internal_stats, methods=["GET"]),
Route("/api/v1/users", create_user, methods=["POST"]),
Route("/api/v1/users/me", me, methods=["GET"]),
Route("/api/v1/auth/sessions", create_session, methods=["POST"]),
Route("/api/v1/auth/sessions/current", delete_session, methods=["DELETE"]),
Route("/api/v1/chats", create_chat, methods=["POST"]),
Route("/api/v1/chats", list_chats, methods=["GET"]),
Route("/api/v1/chats/{chat_id}", get_chat, methods=["GET"]),
Route("/api/v1/chats/{chat_id}/messages", create_message, methods=["POST"]),
Route("/api/v1/chats/{chat_id}/messages", list_messages, methods=["GET"]),
Route("/api/v1/chats/{chat_id}/attachments", endpoint(upload_attachment, "upload_timeout_seconds"), methods=["POST"]),
Route("/api/v1/attachments/{attachment_id}", get_attachment, methods=["GET"]),
Route("/api/v1/attachments/{attachment_id}/content", endpoint(download_attachment), methods=["GET"]),
]
app = Starlette(routes=routes, lifespan=lifespan,
exception_handlers={HTTPException: http_exception, Exception: server_error})
app.add_middleware(RequestContextMiddleware, instance_id=settings.instance_id, state=state)
app.state.messenger = state
return app
__all__ = ["build_app"]
+161
View File
@@ -0,0 +1,161 @@
"""Конфигурация из окружения. Секреты читаются из *_FILE (Docker/Compose secrets)."""
from __future__ import annotations
import os
import secrets
from dataclasses import dataclass
from pathlib import Path
class ConfigError(RuntimeError):
pass
def _secret(name: str, required: bool) -> str | None:
"""Значение NAME или содержимое файла NAME_FILE (приоритет у файла)."""
path = os.environ.get(name + "_FILE")
if path:
try:
value = Path(path).read_text(encoding="utf-8").strip()
except OSError as exc:
raise ConfigError(f"cannot read {name}_FILE") from exc
if not value:
raise ConfigError(f"{name}_FILE is empty")
return value
value = os.environ.get(name, "").strip()
if value:
return value
if required:
raise ConfigError(f"{name} or {name}_FILE is required")
return None
def _int(name: str, default: int, lo: int, hi: int) -> int:
raw = os.environ.get(name)
if raw is None or raw == "":
return default
try:
value = int(raw)
except ValueError as exc:
raise ConfigError(f"{name} must be an integer") from exc
if not lo <= value <= hi:
raise ConfigError(f"{name} must be in [{lo}, {hi}]")
return value
def _float(name: str, default: float, lo: float, hi: float) -> float:
raw = os.environ.get(name)
if raw is None or raw == "":
return default
try:
value = float(raw)
except ValueError as exc:
raise ConfigError(f"{name} must be a number") from exc
if not lo <= value <= hi:
raise ConfigError(f"{name} must be in [{lo}, {hi}]")
return value
@dataclass(frozen=True)
class Settings:
host: str
port: int
env: str
database_url: str
cache_url: str | None
session_ttl_seconds: int
session_cache_ttl_seconds: int
cache_timeout_seconds: float
cache_retry_seconds: float
db_pool_min: int
db_pool_max: int
db_pool_timeout_seconds: float
db_connect_timeout_seconds: int
db_statement_timeout_ms: int
request_timeout_seconds: float
max_body_bytes: int
kdf_concurrency: int
scrypt_log2_n: int
scrypt_r: int
scrypt_p: int
migrate_on_start: bool
migrate_wait_seconds: int
instance_id: str
instance_id_file: str
idempotency_ttl_seconds: int
shutdown_drain_seconds: float
s3_endpoint: str | None
s3_region: str
s3_bucket: str
s3_access_key: str | None
s3_secret_key: str | None
s3_timeout_seconds: float
max_upload_bytes: int
max_image_pixels: int
upload_concurrency: int
upload_timeout_seconds: float
upload_grace_seconds: int
janitor_interval_seconds: float
fault_inject: str
@property
def cache_enabled(self) -> bool:
return self.cache_url is not None
def load() -> Settings:
store = os.environ.get("SESSION_STORE", "postgres").strip()
if store != "postgres":
# Источник истины сессий — всегда PostgreSQL; Redis/Valkey — только кэш (см. REPORT.md).
raise ConfigError("SESSION_STORE must be 'postgres' (Redis/Valkey is a cache via CACHE_URL)")
cache_mode = os.environ.get("SESSION_CACHE", "auto").strip()
if cache_mode not in {"auto", "redis", "off"}:
raise ConfigError("SESSION_CACHE must be auto, redis or off")
cache_url = None if cache_mode == "off" else _secret("CACHE_URL", required=cache_mode == "redis")
pool_max = _int("DB_POOL_MAX", 10, 1, 100)
return Settings(
host=os.environ.get("APP_HOST", "0.0.0.0"),
port=_int("APP_PORT", 8080, 1, 65535),
env=os.environ.get("APP_ENV", "lab"),
database_url=_secret("DATABASE_URL", required=True) or "",
cache_url=cache_url,
session_ttl_seconds=_int("SESSION_TTL_SECONDS", 3600, 1, 30 * 24 * 3600),
session_cache_ttl_seconds=_int("SESSION_CACHE_TTL_SECONDS", 60, 1, 3600),
cache_timeout_seconds=_float("CACHE_TIMEOUT_SECONDS", 0.2, 0.01, 5),
cache_retry_seconds=_float("CACHE_RETRY_SECONDS", 2.0, 0.1, 60),
db_pool_min=min(_int("DB_POOL_MIN", 1, 0, 100), pool_max),
db_pool_max=pool_max,
db_pool_timeout_seconds=_float("DB_POOL_TIMEOUT_SECONDS", 2.0, 0.1, 60),
db_connect_timeout_seconds=_int("DB_CONNECT_TIMEOUT_SECONDS", 3, 1, 60),
db_statement_timeout_ms=_int("DB_STATEMENT_TIMEOUT_MS", 5000, 100, 600000),
request_timeout_seconds=_float("REQUEST_TIMEOUT_SECONDS", 10.0, 1, 120),
max_body_bytes=_int("MAX_BODY_BYTES", 65536, 1024, 1048576),
kdf_concurrency=_int("KDF_CONCURRENCY", 4, 1, 64),
scrypt_log2_n=_int("SCRYPT_LOG2_N", 15, 14, 20),
scrypt_r=_int("SCRYPT_R", 8, 1, 32),
scrypt_p=_int("SCRYPT_P", 3, 1, 16),
# lab3: миграции выполняет отдельный one-shot сервис `migrate`; реплики их только проверяют.
migrate_on_start=os.environ.get("MIGRATE_ON_START", "false").lower() in {"1", "true", "yes"},
migrate_wait_seconds=_int("MIGRATE_WAIT_SECONDS", 60, 0, 600),
# Непрозрачный alias реплики: случайный на каждый запуск процесса, без hostname/IP.
instance_id=os.environ.get("INSTANCE_ID") or "api-" + secrets.token_hex(4),
instance_id_file=os.environ.get("INSTANCE_ID_FILE", "/tmp/instance-id"),
idempotency_ttl_seconds=_int("IDEMPOTENCY_TTL_SECONDS", 86400, 60, 30 * 24 * 3600),
shutdown_drain_seconds=_float("SHUTDOWN_DRAIN_SECONDS", 3.0, 0, 60),
# lab4: S3 (SeaweedFS). Ключи API — отдельная identity с правами только на свой bucket.
s3_endpoint=os.environ.get("S3_ENDPOINT") or None,
s3_region=os.environ.get("S3_REGION", "us-east-1"),
s3_bucket=os.environ.get("S3_BUCKET", "messenger-attachments"),
s3_access_key=_secret("S3_ACCESS_KEY_ID", required=False),
s3_secret_key=_secret("S3_SECRET_ACCESS_KEY", required=False),
s3_timeout_seconds=_float("S3_TIMEOUT_SECONDS", 30.0, 1, 300),
max_upload_bytes=_int("MAX_UPLOAD_BYTES", 10485760, 1024, 10485760),
max_image_pixels=_int("MAX_IMAGE_PIXELS", 40000000, 1, 40000000),
upload_concurrency=_int("UPLOAD_CONCURRENCY", 16, 1, 256),
upload_timeout_seconds=_float("UPLOAD_TIMEOUT_SECONDS", 120.0, 5, 600),
# Grace period очистки: намерение/объект моложе него не трогаются (загрузка может ещё идти).
upload_grace_seconds=_int("UPLOAD_GRACE_SECONDS", 900, 1, 7 * 24 * 3600),
janitor_interval_seconds=_float("JANITOR_INTERVAL_SECONDS", 60.0, 0.5, 3600),
# Только для тестового сервиса api-fault: внедрение отказа между S3 PUT и COMMIT.
fault_inject=os.environ.get("FAULT_INJECT", ""),
)
+129
View File
@@ -0,0 +1,129 @@
"""Пул соединений PostgreSQL, версионируемые миграции и классификация ошибок БД."""
from __future__ import annotations
import asyncio
import hashlib
import logging
import time
from datetime import datetime, timezone
from pathlib import Path
import psycopg
from psycopg import errors as pg_errors
from psycopg.rows import dict_row
from psycopg_pool import AsyncConnectionPool, PoolTimeout
from .config import Settings
log = logging.getLogger("messenger.db")
MIGRATIONS_DIR = Path(__file__).resolve().parents[2] / "migrations"
MIGRATION_LOCK_ID = 2026_0202 # pg_advisory_lock: параллельные реплики не применяют миграции дважды
def connection_kwargs(settings: Settings) -> dict:
options = (
f"-c statement_timeout={settings.db_statement_timeout_ms} "
"-c lock_timeout=2000 "
"-c idle_in_transaction_session_timeout=10000 "
"-c TimeZone=UTC"
)
return {
"connect_timeout": settings.db_connect_timeout_seconds,
"application_name": "messenger-api",
"options": options,
"row_factory": dict_row,
}
def make_pool(settings: Settings) -> AsyncConnectionPool:
return AsyncConnectionPool(
conninfo=settings.database_url,
kwargs=connection_kwargs(settings),
min_size=settings.db_pool_min,
max_size=settings.db_pool_max,
timeout=settings.db_pool_timeout_seconds, # ожидание свободного соединения
max_waiting=200, # очередь ожидания ограничена
max_idle=300,
reconnect_timeout=30,
check=AsyncConnectionPool.check_connection, # после рестарта PG битые соединения отбрасываются
open=False,
name="messenger",
)
def is_unavailable(exc: BaseException) -> bool:
"""Ошибки, означающие «зависимость недоступна/перегружена», а не баг приложения."""
if isinstance(exc, (PoolTimeout, psycopg.OperationalError, asyncio.TimeoutError, ConnectionError)):
return True
return isinstance(exc, (pg_errors.QueryCanceled, pg_errors.LockNotAvailable,
pg_errors.AdminShutdown, pg_errors.CannotConnectNow))
def iso(ts: datetime) -> str:
"""RFC 3339 UTC с микросекундами и суффиксом Z (точность timestamptz в PostgreSQL)."""
return ts.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def _migration_files() -> list[tuple[str, str, str]]:
result = []
for path in sorted(MIGRATIONS_DIR.glob("[0-9][0-9][0-9][0-9]_*.sql")):
sql = path.read_text(encoding="utf-8")
result.append((path.stem, sql, hashlib.sha256(sql.encode()).hexdigest()))
return result
async def migrate(settings: Settings) -> list[str]:
"""Применяет недостающие миграции. Повторный запуск — no-op; изменённая применённая миграция —
ошибка (миграции неизменяемы, исправления — новой версией)."""
applied_now: list[str] = []
async with await psycopg.AsyncConnection.connect(
settings.database_url, autocommit=True, **connection_kwargs(settings)) as conn:
await conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATION_LOCK_ID,))
try:
await conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
" version text PRIMARY KEY, checksum text NOT NULL,"
" applied_at timestamptz NOT NULL DEFAULT clock_timestamp())")
rows = await (await conn.execute("SELECT version, checksum FROM schema_migrations")).fetchall()
done = {r["version"]: r["checksum"] for r in rows}
for version, sql, checksum in _migration_files():
if version in done:
if done[version] != checksum:
raise RuntimeError(f"applied migration {version} was modified")
continue
async with conn.transaction():
await conn.execute(sql)
await conn.execute(
"INSERT INTO schema_migrations (version, checksum) VALUES (%s, %s)",
(version, checksum))
applied_now.append(version)
log.info("migration applied", extra={"version": version})
finally:
await conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATION_LOCK_ID,))
return applied_now
async def schema_status(pool) -> tuple[bool, list[str]]:
"""Совместима ли схема с этим кодом: применены все известные ему миграции с теми же checksum.
Более новые миграции (expand-фаза следующей версии) допустимы."""
async with pool.connection() as conn:
rows = await (await conn.execute(
"SELECT version, checksum FROM schema_migrations")).fetchall()
done = {r["version"]: r["checksum"] for r in rows}
missing = [v for v, _, c in _migration_files() if done.get(v) != c]
return not missing, missing
async def migrate_with_wait(settings: Settings) -> list[str]:
deadline = time.monotonic() + settings.migrate_wait_seconds
delay = 0.5
while True:
try:
return await migrate(settings)
except psycopg.OperationalError:
if time.monotonic() >= deadline:
raise
log.warning("database not reachable yet; retrying migrations")
await asyncio.sleep(delay)
delay = min(delay * 2, 5)
+67
View File
@@ -0,0 +1,67 @@
"""Единый формат ошибок API: {"error":{"code","message","request_id"}}."""
from __future__ import annotations
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
_STATUS = {
"invalid_request": 400,
"unauthorized": 401,
"not_found": 404,
"method_not_allowed": 405,
"conflict": 409,
"payload_too_large": 413,
"unsupported_media_type": 415,
"rate_limited": 429,
"internal_error": 500,
"unavailable": 503,
}
_DEFAULT_MESSAGE = {
"invalid_request": "Некорректный запрос",
"unauthorized": "Требуется действительная аутентификация",
"not_found": "Объект не найден",
"conflict": "Конфликт состояния",
"payload_too_large": "Слишком большой запрос",
"unsupported_media_type": "Неподдерживаемый тип содержимого",
"rate_limited": "Слишком много запросов",
"internal_error": "Внутренняя ошибка",
"unavailable": "Сервис временно недоступен",
}
class ApiError(Exception):
def __init__(self, code: str, message: str | None = None, *, challenge: str | None = None,
headers: dict[str, str] | None = None):
super().__init__(code)
self.code = code
self.status = _STATUS[code]
self.message = message or _DEFAULT_MESSAGE.get(code, "Ошибка")
self.headers = dict(headers or {})
if challenge:
self.headers["WWW-Authenticate"] = challenge
@property
def public_code(self) -> str:
# 405 не входит в enum контракта: отдаём invalid_request с корректным HTTP-статусом.
return "invalid_request" if self.code == "method_not_allowed" else self.code
def invalid(message: str) -> ApiError:
return ApiError("invalid_request", message)
def unauthorized_bearer() -> ApiError:
return ApiError("unauthorized", challenge=BEARER_CHALLENGE)
def unauthorized_basic() -> ApiError:
return ApiError("unauthorized", "Неверные учётные данные", challenge=BASIC_CHALLENGE)
def not_found() -> ApiError:
return ApiError("not_found")
def unavailable() -> ApiError:
return ApiError("unavailable", headers={"Retry-After": "1"})
+307
View File
@@ -0,0 +1,307 @@
"""Потоковая проверка PNG/JPEG без декодирования в память.
Валидатор получает байты кусками (как они приходят от клиента), держит O(64 КиБ) состояния и
бросает ImageRejected как можно раньше:
* формат определяется по содержимому (magic), а не по Content-Type/filename;
* размеры берутся из IHDR (PNG) / SOF (JPEG): превышение MAX_IMAGE_PIXELS → 413 ещё до чтения
пиксельных данных — «бомба» не распаковывается;
* PNG: проверяются CRC всех чанков, порядок IHDR…IDAT…IEND, допустимые bit depth/color type,
поток IDAT реально распаковывается zlib по частям (вывод выбрасывается), объём распакованных
данных обязан совпасть с ожидаемым по размерам — повреждение и «бомбы» отсекаются;
* JPEG: структура маркеров до SOS, entropy-coded данные сканируются до EOI (RST/stuffing),
обязателен SOF с ненулевыми размерами и EOI в конце. Полное Huffman-декодирование не выполняется:
«заведомо повреждённые» (обрезанные, мусор, неверные сегменты) отклоняются, тонкие ошибки внутри
entropy-потока — нет (ограничение описано в REPORT.md).
"""
from __future__ import annotations
import struct
import zlib
PNG_SIG = b"\x89PNG\r\n\x1a\n"
PNG_COLOR = {0: (1, {1, 2, 4, 8, 16}), 2: (3, {8, 16}), 3: (1, {1, 2, 4, 8}), 4: (2, {8, 16}), 6: (4, {8, 16})}
JPEG_SOF = {0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF}
MAX_SEGMENT = 1 << 24
class ImageRejected(Exception):
def __init__(self, kind: str, message: str):
super().__init__(message)
self.kind = kind # "too_large" → 413, "invalid" → 415
def sniff(head: bytes) -> str | None:
if head.startswith(PNG_SIG):
return "image/png"
if head.startswith(b"\xff\xd8\xff"):
return "image/jpeg"
return None
def _bad(msg):
return ImageRejected("invalid", msg)
class _Buf:
"""Маленький буфер «нужно N байт»; крупные данные проходят мимо через take_upto()."""
def __init__(self):
self.data = bytearray()
def feed(self, b):
self.data += b
def take(self, n):
if len(self.data) < n:
return None
out = bytes(self.data[:n])
del self.data[:n]
return out
def take_upto(self, n):
out = bytes(self.data[:n])
del self.data[:len(out)]
return out
class PngValidator:
def __init__(self, max_pixels: int):
self.max_pixels, self.buf = max_pixels, _Buf()
self.state, self.width, self.height = "sig", None, None
self.chunk_type, self.remaining, self.crc = None, 0, 0
self.seen_idat = self.seen_iend = self.seen_plte = False
self.idat_done = False
self.expected_raw = 0
self.decompressed = 0
self.z = zlib.decompressobj()
def _ihdr(self, data):
if len(data) != 13:
raise _bad("bad IHDR")
w, h, depth, ctype, comp, flt, interlace = struct.unpack(">IIBBBBB", data)
if not (0 < w < 2**31 and 0 < h < 2**31) or ctype not in PNG_COLOR or depth not in PNG_COLOR[ctype][1] \
or comp != 0 or flt != 0 or interlace not in (0, 1):
raise _bad("bad IHDR fields")
if w * h > self.max_pixels:
raise ImageRejected("too_large", "image has %d pixels" % (w * h))
self.width, self.height, self.ctype = w, h, ctype
bpp = PNG_COLOR[ctype][0] * depth
rowbytes = lambda width: (width * bpp + 7) // 8 # noqa: E731
if interlace == 0:
self.expected_raw = h * (1 + rowbytes(w))
else:
total = 0
for xs, ys, dx, dy in ((0, 0, 8, 8), (4, 0, 8, 8), (0, 4, 4, 8), (2, 0, 4, 4), (0, 2, 2, 4), (1, 0, 2, 2), (0, 1, 1, 2)):
pw, ph = (w - xs + dx - 1) // dx, (h - ys + dy - 1) // dy
if pw > 0 and ph > 0:
total += ph * (1 + rowbytes(pw))
self.expected_raw = total
def _inflate(self, data):
if self.idat_done:
raise _bad("IDAT chunks are not contiguous")
pending = data
while pending:
out = self.z.decompress(pending, 1 << 20) # не больше 1 МиБ за шаг — RAM ограничена
self.decompressed += len(out)
if self.decompressed > self.expected_raw:
raise _bad("image data larger than declared dimensions")
pending = self.z.unconsumed_tail
if self.z.eof and (pending or self.z.unused_data):
raise _bad("trailing data after zlib stream")
def feed(self, chunk: bytes):
self.buf.feed(chunk)
while True:
if self.state == "sig":
sig = self.buf.take(8)
if sig is None:
return
if sig != PNG_SIG:
raise _bad("not a PNG")
self.state = "hdr"
elif self.state == "hdr":
hdr = self.buf.take(8)
if hdr is None:
return
if self.seen_iend:
raise _bad("data after IEND")
length, ctype = struct.unpack(">I4s", hdr)
if length > MAX_SEGMENT or not ctype.isalpha():
raise _bad("bad chunk header")
if self.width is None and ctype != b"IHDR":
raise _bad("IHDR must be first")
if ctype != b"IDAT" and self.seen_idat:
self.idat_done = True
self.chunk_type, self.remaining, self.crc = ctype, length, zlib.crc32(ctype)
self.small = bytearray() if ctype in (b"IHDR", b"PLTE") else None
self.state = "data"
elif self.state == "data":
piece = self.buf.take_upto(self.remaining)
if not piece and self.remaining:
return
self.remaining -= len(piece)
self.crc = zlib.crc32(piece, self.crc)
if self.small is not None:
self.small += piece
if self.chunk_type == b"IDAT":
if self.width is None or (self.ctype == 3 and not self.seen_plte):
raise _bad("IDAT before IHDR/PLTE")
self.seen_idat = True
self._inflate(piece)
if self.remaining == 0:
self.state = "crc"
elif self.state == "crc":
crc = self.buf.take(4)
if crc is None:
return
if struct.unpack(">I", crc)[0] != self.crc & 0xFFFFFFFF:
raise _bad("chunk CRC mismatch")
if self.chunk_type == b"IHDR":
if self.width is not None:
raise _bad("duplicate IHDR")
self._ihdr(bytes(self.small))
elif self.chunk_type == b"PLTE":
self.seen_plte = True
elif self.chunk_type == b"IEND":
self.seen_iend = True
self.state = "hdr"
def finish(self):
if self.buf.data or self.state != "hdr" or not self.seen_iend:
raise _bad("truncated PNG")
if not self.seen_idat or not self.z.eof or self.decompressed != self.expected_raw:
raise _bad("incomplete or corrupt image data")
return self.width, self.height
class JpegValidator:
def __init__(self, max_pixels: int):
self.max_pixels, self.buf = max_pixels, _Buf()
self.state, self.width, self.height = "soi", None, None
self.remaining, self.marker, self.seg = 0, None, None
self.seen_eoi = False
self.prev_ff = False
self.trailing = 0
def _sof(self, data):
if len(data) < 6:
raise _bad("bad SOF")
_prec, h, w, ncomp = struct.unpack(">BHHB", data[:6])
if h == 0 or w == 0 or ncomp not in (1, 3, 4) or len(data) < 6 + 3 * ncomp:
raise _bad("bad SOF fields")
if w * h > self.max_pixels:
raise ImageRejected("too_large", "image has %d pixels" % (w * h))
self.width, self.height = w, h
def feed(self, chunk: bytes):
self.buf.feed(chunk)
while True:
if self.state == "soi":
b = self.buf.take(2)
if b is None:
return
if b != b"\xff\xd8":
raise _bad("not a JPEG")
self.state = "marker"
elif self.state == "marker":
d = self.buf.data
i = 0
while i < len(d) and d[i] == 0xFF and i + 1 < len(d) and d[i + 1] == 0xFF:
i += 1 # fill bytes
del d[:i]
b = self.buf.take(2)
if b is None:
return
if b[0] != 0xFF:
raise _bad("marker expected")
m = b[1]
if m == 0xD9:
if self.width is None:
raise _bad("EOI before SOF")
self.seen_eoi, self.state = True, "trailing"
elif m in (0x01,) or 0xD0 <= m <= 0xD7:
continue
elif m in (0xD8, 0x00):
raise _bad("unexpected marker")
else:
self.marker, self.state = m, "len"
elif self.state == "len":
b = self.buf.take(2)
if b is None:
return
length = struct.unpack(">H", b)[0]
if length < 2:
raise _bad("bad segment length")
self.remaining = length - 2
keep = self.marker in JPEG_SOF or self.marker == 0xDA
self.seg = bytearray() if keep else None
self.state = "seg"
elif self.state == "seg":
piece = self.buf.take_upto(self.remaining)
if not piece and self.remaining:
return
self.remaining -= len(piece)
if self.seg is not None:
self.seg += piece
if self.remaining == 0:
if self.marker in JPEG_SOF:
if self.width is not None:
raise _bad("duplicate SOF")
self._sof(bytes(self.seg))
self.state = "marker"
elif self.marker == 0xDA:
if self.width is None:
raise _bad("SOS before SOF")
self.state, self.prev_ff = "scan", False
else:
self.state = "marker"
elif self.state == "scan":
d = self.buf.data
if not d:
return
i = 0
n = len(d)
while i < n:
if self.prev_ff:
x = d[i]
self.prev_ff = False
if x == 0x00 or 0xD0 <= x <= 0xD7:
i += 1
continue
if x == 0xFF:
self.prev_ff = True
i += 1
continue
# конец entropy-данных: вернуть "FF xx" для разбора маркера
del d[:i - 1]
self.state = "marker"
break
j = d.find(b"\xff", i)
if j < 0:
i = n
break
self.prev_ff, i = True, j + 1
else:
pass
if self.state == "scan":
keep = 1 if self.prev_ff else 0
del d[:n - keep]
if keep:
self.prev_ff = False # байт FF оставлен в буфере, разберём при следующей порции
return
elif self.state == "trailing":
self.trailing += len(self.buf.data)
self.buf.data.clear()
if self.trailing > 1 << 20:
raise _bad("too much data after EOI")
return
def finish(self):
if not self.seen_eoi:
raise _bad("truncated JPEG (no EOI)")
return self.width, self.height
def validator_for(content_type: str, max_pixels: int):
return PngValidator(max_pixels) if content_type == "image/png" else JpegValidator(max_pixels)
+362
View File
@@ -0,0 +1,362 @@
"""Reconciler PostgreSQL ↔ S3 (трек 2): поиск и безопасное исправление расхождений.
python -m messenger reconcile # dry-run: только отчёт (по умолчанию)
python -m messenger reconcile --apply # исправить то, что безопасно исправляется
python -m messenger reconcile --verify-checksums # дополнительно скачать объекты и сверить SHA-256
python -m messenger reconcile --grace-seconds 900 --prefix attachments/ --json evidence/r.json
Порядок обхода выбран так, чтобы гонки с живыми загрузками не давали ложных решений:
1. t0 = clock_timestamp() PostgreSQL; затем ListObjectsV2 по префиксу (снимок S3);
2. ПОСЛЕ листинга — снимок БД (attachments + ссылки из сообщений + upload_intents).
Загрузка пишет intent ДО S3 PUT и снимает его в одной транзакции с INSERT attachments, поэтому
любой объект из листинга либо уже имеет строку attachments, либо всё ещё имеет intent, либо
действительно orphan. Объект, появившийся после листинга, в отчёт не попадает вовсе.
3. Перед каждым разрушающим действием условие перепроверяется точечно в той же транзакции
(строка/ссылки/intent), а сами DELETE защищены условиями и FK.
Классы:
ok — объект есть, размер совпадает (и SHA-256 при --verify-checksums);
orphan — объект без метаданных и без intent, старше grace → удаляется (--apply);
orphan_fresh — то же, но моложе grace → не трогаем (возможна гонка с COMMIT);
in_progress — объект/ключ с живым intent моложе grace → не трогаем;
stale_intent — intent старше grace (упала реплика) → объект без метаданных удаляется,
intent снимается (как janitor);
missing_unreferenced— строка attachments есть, объекта нет, сообщения на неё не ссылаются,
вложение старше grace → строка удаляется (её нельзя использовать);
missing_referenced — объекта нет, но вложение уже в сообщениях → метаданные НЕ удаляются
(сломали бы историю), ставится флаг attachment_integrity=missing_object;
missing_fresh — объекта нет, вложение моложе grace → только отчёт;
size_mismatch / checksum_mismatch — флаг attachment_integrity, данные не удаляются;
multipart_stale — незавершённая multipart-загрузка старше grace → abort.
Флаги, которые больше не подтверждаются (объект восстановили из backup), снимаются.
Повторный запуск идемпотентен: после --apply второй прогон показывает только флаги/ok.
Одновременно с janitor не выполняется: общий pg_advisory_lock (JANITOR_LOCK_ID).
Код выхода: 0 — расхождений, требующих действий, нет; 2 — есть (в dry-run или оставшиеся); 1 — ошибка.
"""
from __future__ import annotations
import argparse
import asyncio
import datetime as dt
import hashlib
import json
import os
import resource
import sys
import time
import psycopg
from psycopg.rows import dict_row
from .app import JANITOR_LOCK_ID
from .config import _secret
from .s3 import S3Client
SAMPLE = 20 # сколько ключей каждого класса показывать в отчёте
def _parse(argv):
p = argparse.ArgumentParser(prog="python -m messenger reconcile")
p.add_argument("--apply", action="store_true", help="исправлять (по умолчанию dry-run)")
p.add_argument("--grace-seconds", type=float,
default=float(os.environ.get("RECONCILE_GRACE_SECONDS", os.environ.get("UPLOAD_GRACE_SECONDS", "900"))))
p.add_argument("--verify-checksums", action="store_true", help="скачать объекты и сверить SHA-256")
p.add_argument("--prefix", default="attachments/")
p.add_argument("--json", dest="json_path", help="дополнительно записать отчёт в файл")
p.add_argument("--no-lock", action="store_true", help="не брать advisory lock (только для dry-run)")
p.add_argument("--samples", type=int, default=20, help="сколько ключей каждого класса показать")
a = p.parse_args(argv)
if a.no_lock and a.apply:
p.error("--no-lock разрешён только в dry-run")
if a.grace_seconds < 0:
p.error("--grace-seconds must be >= 0")
return a
class Report:
def __init__(self):
self.counts: dict[str, int] = {}
self.samples: dict[str, list] = {}
self.actions: dict[str, int] = {}
self.errors: list[str] = []
def add(self, cls: str, item):
self.counts[cls] = self.counts.get(cls, 0) + 1
if item is None:
return
lst = self.samples.setdefault(cls, [])
if len(lst) < SAMPLE:
lst.append(item)
def act(self, name: str):
self.actions[name] = self.actions.get(name, 0) + 1
ACTIONABLE = {"orphan", "stale_intent", "missing_unreferenced", "multipart_stale",
"missing_object_unflagged", "size_mismatch_unflagged", "checksum_mismatch_unflagged",
"flag_resolved"}
async def run(args) -> dict:
global SAMPLE
SAMPLE = max(0, args.samples)
bucket = os.environ.get("S3_BUCKET", "messenger-attachments")
s3 = S3Client(os.environ.get("S3_ENDPOINT", "http://s3:9000"), os.environ.get("S3_REGION", "us-east-1"),
_secret("S3_ACCESS_KEY_ID", required=True), _secret("S3_SECRET_ACCESS_KEY", required=True),
timeout=30)
rep = Report()
timings: dict[str, float] = {}
grace = dt.timedelta(seconds=args.grace_seconds)
# Intent живой загрузки защищён минимум на UPLOAD_TIMEOUT_SECONDS + 5 даже при маленьком --grace-seconds.
upload_timeout = float(os.environ.get("UPLOAD_TIMEOUT_SECONDS", "120"))
intent_grace = dt.timedelta(seconds=max(args.grace_seconds, upload_timeout + 5))
conn = await psycopg.AsyncConnection.connect(_secret("DATABASE_URL", required=True), row_factory=dict_row,
autocommit=True, application_name="messenger-reconcile",
options="-c TimeZone=UTC -c lock_timeout=2000")
started = time.perf_counter()
try:
if not args.no_lock:
got = await (await conn.execute("SELECT pg_try_advisory_lock(%s) AS ok", (JANITOR_LOCK_ID,))).fetchone()
if not got["ok"]:
raise RuntimeError("другой reconciler/janitor держит lock; повторите позже")
t0 = (await (await conn.execute("SELECT clock_timestamp() AS t")).fetchone())["t"]
# 1) снимок S3
t = time.perf_counter()
objects = {}
async for o in s3.list_objects(bucket, prefix=args.prefix):
objects[o.key] = o
multipart = await s3.list_multipart_uploads(bucket, prefix=args.prefix)
timings["s3_list_seconds"] = round(time.perf_counter() - t, 4)
list_requests = s3.requests
# 2) снимок БД — строго после листинга, attachments и intents одним REPEATABLE READ-снимком
t = time.perf_counter()
await conn.execute("BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY")
rows = await (await conn.execute(
"SELECT a.id, a.object_key, a.size_bytes, a.sha256, a.created_at,"
" EXISTS (SELECT 1 FROM message_attachments m WHERE m.attachment_id = a.id) AS referenced,"
" i.problem AS flagged"
" FROM attachments a LEFT JOIN attachment_integrity i ON i.attachment_id = a.id"
" WHERE a.object_key LIKE %s", (args.prefix.replace("%", r"\%") + "%",))).fetchall()
meta = {r["object_key"]: r for r in rows}
intents = {r["object_key"]: r for r in await (await conn.execute(
"SELECT object_key, attachment_id, created_at FROM upload_intents")).fetchall()}
await conn.execute("COMMIT")
timings["db_snapshot_seconds"] = round(time.perf_counter() - t, 4)
# 3) классификация
t = time.perf_counter()
plan = [] # (класс, ключ/id, действие)
for key, o in objects.items():
if key in meta:
continue
it = intents.get(key)
if it is not None:
if t0 - it["created_at"] > intent_grace:
rep.add("stale_intent", key)
plan.append(("stale_intent", key))
else:
rep.add("in_progress", key)
elif t0 - o.last_modified > grace:
rep.add("orphan", {"key": key, "size": o.size, "age_s": int((t0 - o.last_modified).total_seconds())})
plan.append(("orphan", key))
else:
rep.add("orphan_fresh", key)
for key, it in intents.items(): # intent без объекта (упали до/во время PUT) или забытый после COMMIT
if (key not in objects or key in meta) and t0 - it["created_at"] > intent_grace:
rep.add("stale_intent", key)
plan.append(("stale_intent", key))
for key, r in meta.items():
aid = str(r["id"])
o = objects.get(key)
problem = None
if o is None:
if t0 - r["created_at"] <= grace:
rep.add("missing_fresh", aid)
continue
if r["referenced"]:
problem = "missing_object"
rep.add("missing_referenced", aid)
else:
rep.add("missing_unreferenced", aid)
plan.append(("missing_unreferenced", aid))
continue
elif o.size != r["size_bytes"]:
problem = "size_mismatch"
rep.add("size_mismatch", {"id": aid, "db": r["size_bytes"], "s3": o.size})
elif args.verify_checksums:
digest = await _sha256(s3, bucket, key)
if digest is None: # исчез между листингом и GET — разберёт следующий прогон
rep.add("vanished_during_scan", aid)
continue
if digest != r["sha256"]:
problem = "checksum_mismatch"
rep.add("checksum_mismatch", aid)
if problem is None and r["flagged"] == "checksum_mismatch" and not args.verify_checksums:
rep.add("checksum_flag_kept_unverified", aid) # без --verify-checksums снять флаг нечем
continue
if problem is None:
rep.add("ok", None)
if r["flagged"]:
rep.add("flag_resolved", aid)
plan.append(("flag_resolved", aid))
elif r["flagged"] != problem:
rep.add(problem + "_unflagged", aid)
plan.append(("flag", aid, problem))
stale_mp = [u for u in multipart
if u["initiated"] and t0 - dt.datetime.fromisoformat(u["initiated"].replace("Z", "+00:00")) > grace]
for u in stale_mp:
rep.add("multipart_stale", u["key"])
plan.append(("multipart_stale", u["key"], u["upload_id"]))
timings["classify_seconds"] = round(time.perf_counter() - t, 4)
# 4) исправление (только --apply), каждое действие перепроверяется точечно
t = time.perf_counter()
if args.apply:
for step in plan:
try:
await _apply(step, conn, s3, bucket, intent_grace, rep)
except Exception as exc: # noqa: BLE001 — одна ошибка не останавливает обход
rep.errors.append(f"{step[0]} {step[1]}: {type(exc).__name__}: {str(exc)[:120]}")
timings["apply_seconds"] = round(time.perf_counter() - t, 4)
finally:
if not args.no_lock:
try:
await conn.execute("SELECT pg_advisory_unlock(%s)", (JANITOR_LOCK_ID,))
except Exception: # noqa: BLE001
pass
await conn.close()
await s3.aclose()
timings["total_seconds"] = round(time.perf_counter() - started, 4)
pending = {k: v for k, v in rep.counts.items() if k in ACTIONABLE}
return {
"mode": "apply" if args.apply else "dry-run",
"bucket": bucket, "prefix": args.prefix, "grace_seconds": args.grace_seconds,
"intent_grace_seconds": intent_grace.total_seconds(),
"verify_checksums": args.verify_checksums,
"scanned": {"s3_objects": len(objects), "db_attachments": len(meta), "upload_intents": len(intents),
"multipart_uploads": len(multipart)},
"counts": dict(sorted(rep.counts.items())),
"actions": rep.actions,
"actionable_found": pending,
"samples": rep.samples,
"errors": rep.errors,
"cost": {**timings, "s3_requests_total": s3.requests, "s3_list_requests": list_requests,
"peak_rss_kib": resource.getrusage(resource.RUSAGE_SELF).ru_maxrss},
}
async def _sha256(s3: S3Client, bucket: str, key: str) -> str | None:
from .s3 import S3Error
try:
resp = await s3.get_object_stream(bucket, key)
except S3Error as exc:
if exc.status == 404:
return None
raise
h = hashlib.sha256()
try:
async for chunk in resp.aiter_bytes(65536):
h.update(chunk)
finally:
await resp.aclose()
return h.hexdigest()
async def _apply(step, conn, s3: S3Client, bucket: str, grace, rep: Report):
kind = step[0]
if kind == "orphan":
key = step[1]
# перепроверка: метаданные/intent могли появиться после снимка
again = await (await conn.execute(
"SELECT EXISTS (SELECT 1 FROM attachments WHERE object_key = %s)"
" OR EXISTS (SELECT 1 FROM upload_intents WHERE object_key = %s) AS used", (key, key))).fetchone()
if again["used"]:
rep.act("skipped_now_used")
return
head = await s3.head_object(bucket, key)
if head is None:
rep.act("skipped_already_gone")
return
await s3.delete_object(bucket, key)
rep.act("deleted_orphan_object")
elif kind == "stale_intent":
key = step[1]
async with conn.transaction():
it = await (await conn.execute(
"SELECT created_at < clock_timestamp() - %s AS stale,"
" EXISTS (SELECT 1 FROM attachments a WHERE a.object_key = i.object_key) AS committed"
" FROM upload_intents i WHERE object_key = %s FOR UPDATE SKIP LOCKED", (grace, key))).fetchone()
if it is None or not it["stale"]:
rep.act("skipped_intent_changed")
return
if not it["committed"]:
await s3.delete_object(bucket, key) # DELETE несуществующего ключа — тоже 204
rep.act("deleted_stale_upload_object")
await conn.execute("DELETE FROM upload_intents WHERE object_key = %s", (key,))
rep.act("removed_stale_intent")
elif kind == "missing_unreferenced":
aid = step[1]
async with conn.transaction():
row = await (await conn.execute(
"SELECT object_key FROM attachments WHERE id = %s FOR UPDATE", (aid,))).fetchone()
if row is None:
rep.act("skipped_already_gone")
return
if await s3.head_object(bucket, row["object_key"]) is not None:
rep.act("skipped_object_reappeared")
return
# NOT EXISTS + FK без CASCADE: если параллельно сообщение сослалось на вложение, DELETE не пройдёт.
try:
async with conn.transaction(): # savepoint
cur = await conn.execute(
"DELETE FROM attachments a WHERE a.id = %s"
" AND NOT EXISTS (SELECT 1 FROM message_attachments m WHERE m.attachment_id = a.id)", (aid,))
deleted = cur.rowcount
except psycopg.errors.ForeignKeyViolation:
deleted = 0
if deleted:
rep.act("deleted_lost_metadata")
else:
await conn.execute(
"INSERT INTO attachment_integrity (attachment_id, problem) VALUES (%s, 'missing_object')"
" ON CONFLICT (attachment_id) DO UPDATE SET problem = EXCLUDED.problem", (aid,))
rep.act("flagged_missing_object")
elif kind == "flag":
aid, problem = step[1], step[2]
await conn.execute(
"INSERT INTO attachment_integrity (attachment_id, problem) VALUES (%s, %s)"
" ON CONFLICT (attachment_id) DO UPDATE SET problem = EXCLUDED.problem, detected_at = clock_timestamp()",
(aid, problem))
rep.act("flagged_" + problem)
elif kind == "flag_resolved":
await conn.execute("DELETE FROM attachment_integrity WHERE attachment_id = %s", (step[1],))
rep.act("cleared_resolved_flag")
elif kind == "multipart_stale":
await s3.abort_multipart(bucket, step[1], step[2])
rep.act("aborted_multipart")
def main(argv) -> int:
args = _parse(argv)
try:
result = asyncio.run(run(args))
except Exception as exc: # noqa: BLE001
print(json.dumps({"error": f"{type(exc).__name__}: {str(exc)[:300]}"}, ensure_ascii=False), file=sys.stderr)
return 1
text = json.dumps(result, ensure_ascii=False, indent=1, default=str)
print(text)
if args.json_path:
with open(args.json_path, "w", encoding="utf-8") as fh:
fh.write(text + "\n")
if result["errors"]:
return 1
if not args.apply:
return 2 if result["actionable_found"] else 0
return 0
+189
View File
@@ -0,0 +1,189 @@
"""Минимальный асинхронный S3-клиент (AWS Signature V4, path-style) поверх httpx.
Почему свой, а не boto3: нужен потоковый PUT с известным Content-Length без буферизации файла в RAM
и асинхронный стрим GET → HTTP-ответ. Операции — ровно те, что использует сервис:
PUT/GET/HEAD/DELETE объекта, ListObjectsV2, multipart (list/abort), HEAD/PUT bucket (bootstrap).
"""
from __future__ import annotations
import datetime as dt
import hashlib
import hmac
import xml.etree.ElementTree as ET
from dataclasses import dataclass
from urllib.parse import quote, urlsplit
import httpx
EMPTY_SHA256 = hashlib.sha256(b"").hexdigest()
UNSIGNED = "UNSIGNED-PAYLOAD"
NS = "{http://s3.amazonaws.com/doc/2006-03-01/}"
class S3Error(Exception):
"""Ответ S3 с ошибкой (status, code из XML)."""
def __init__(self, status: int, code: str, message: str = ""):
super().__init__(f"S3 {status} {code}: {message}"[:300])
self.status, self.code = status, code
class S3Unavailable(Exception):
"""S3 недоступен (соединение, таймаут, 5xx)."""
@dataclass
class S3Object:
key: str
size: int
last_modified: dt.datetime
etag: str = ""
def _sign(key: bytes, msg: str) -> bytes:
return hmac.new(key, msg.encode(), hashlib.sha256).digest()
def _q(s: str, safe: str = "-_.~") -> str:
return quote(s, safe=safe)
class S3Client:
def __init__(self, endpoint: str, region: str, access_key: str, secret_key: str,
timeout: float = 30.0, connect_timeout: float = 2.0, max_connections: int = 50):
self.endpoint = endpoint.rstrip("/")
self.host = urlsplit(self.endpoint).netloc
self.region, self.access_key, self.secret_key = region, access_key, secret_key
self.client = httpx.AsyncClient(
timeout=httpx.Timeout(timeout, connect=connect_timeout),
limits=httpx.Limits(max_connections=max_connections, max_keepalive_connections=20),
follow_redirects=False)
self.requests = 0
async def aclose(self):
await self.client.aclose()
# ---------------------------------------------------------------- signing
def _headers(self, method: str, path: str, query: dict, payload_hash: str, extra: dict | None = None) -> dict:
now = dt.datetime.now(dt.timezone.utc)
amz_date, day = now.strftime("%Y%m%dT%H%M%SZ"), now.strftime("%Y%m%d")
headers = {"host": self.host, "x-amz-date": amz_date, "x-amz-content-sha256": payload_hash}
for k, v in (extra or {}).items():
headers[k.lower()] = str(v)
signed = sorted(headers)
canonical_query = "&".join(f"{_q(k)}={_q(str(v))}" for k, v in sorted(query.items()))
canonical = "\n".join([method, _q(path, safe="/-_.~"), canonical_query,
"".join(f"{k}:{headers[k].strip()}\n" for k in signed), ";".join(signed), payload_hash])
scope = f"{day}/{self.region}/s3/aws4_request"
to_sign = "\n".join(["AWS4-HMAC-SHA256", amz_date, scope, hashlib.sha256(canonical.encode()).hexdigest()])
k = _sign(_sign(_sign(_sign(("AWS4" + self.secret_key).encode(), day), self.region), "s3"), "aws4_request")
signature = hmac.new(k, to_sign.encode(), hashlib.sha256).hexdigest()
headers["authorization"] = (f"AWS4-HMAC-SHA256 Credential={self.access_key}/{scope}, "
f"SignedHeaders={';'.join(signed)}, Signature={signature}")
del headers["host"]
return headers
async def _request(self, method, path, query=None, content=None, payload_hash=EMPTY_SHA256, extra=None,
stream=False):
query = query or {}
headers = self._headers(method, path, query, payload_hash, extra)
url = self.endpoint + _q(path, safe="/-_.~")
self.requests += 1
try:
req = self.client.build_request(method, url, params=query or None, headers=headers, content=content)
resp = await self.client.send(req, stream=stream)
except (httpx.TransportError, httpx.TimeoutException) as exc:
raise S3Unavailable(type(exc).__name__) from exc
if resp.status_code >= 500:
await resp.aclose()
raise S3Unavailable(f"HTTP {resp.status_code}")
if resp.status_code >= 300 and not (method == "HEAD" and resp.status_code == 404):
body = await resp.aread()
await resp.aclose()
code = ""
try:
code = ET.fromstring(body).findtext("Code") or ""
except ET.ParseError:
pass
raise S3Error(resp.status_code, code or str(resp.status_code), body[:200].decode(errors="replace"))
return resp
# ---------------------------------------------------------------- objects
async def put_object_stream(self, bucket: str, key: str, body, length: int, content_type: str) -> str:
"""Потоковый PUT: тело — async-итератор, длина известна заранее. Подпись UNSIGNED-PAYLOAD
(целостность проверяется самим сервисом по SHA-256 после загрузки и HEAD size)."""
resp = await self._request("PUT", f"/{bucket}/{key}", content=body, payload_hash=UNSIGNED,
extra={"content-length": length, "content-type": content_type})
await resp.aclose()
return resp.headers.get("etag", "")
async def put_object(self, bucket: str, key: str, data: bytes, content_type: str = "application/octet-stream"):
resp = await self._request("PUT", f"/{bucket}/{key}", content=data,
payload_hash=hashlib.sha256(data).hexdigest(),
extra={"content-length": len(data), "content-type": content_type})
await resp.aclose()
async def head_object(self, bucket: str, key: str) -> dict | None:
resp = await self._request("HEAD", f"/{bucket}/{key}")
await resp.aclose()
if resp.status_code == 404:
return None
return {"size": int(resp.headers.get("content-length", 0)), "etag": resp.headers.get("etag", ""),
"content_type": resp.headers.get("content-type", "")}
async def get_object_stream(self, bucket: str, key: str) -> httpx.Response:
"""Возвращает потоковый ответ; вызывающий обязан закрыть его (aclose)."""
return await self._request("GET", f"/{bucket}/{key}", stream=True)
async def delete_object(self, bucket: str, key: str) -> None:
resp = await self._request("DELETE", f"/{bucket}/{key}")
await resp.aclose()
async def list_objects(self, bucket: str, prefix: str = "", page_size: int = 1000):
"""ListObjectsV2 с пагинацией; генератор S3Object."""
token = None
while True:
q = {"list-type": "2", "prefix": prefix, "max-keys": str(page_size)}
if token:
q["continuation-token"] = token
resp = await self._request("GET", f"/{bucket}", query=q)
root = ET.fromstring(await resp.aread())
for c in root.iter(NS + "Contents"):
yield S3Object(key=c.findtext(NS + "Key"), size=int(c.findtext(NS + "Size") or 0),
last_modified=dt.datetime.fromisoformat(c.findtext(NS + "LastModified").replace("Z", "+00:00")),
etag=(c.findtext(NS + "ETag") or "").strip('"'))
if (root.findtext(NS + "IsTruncated") or "false").lower() != "true":
return
token = root.findtext(NS + "NextContinuationToken")
if not token:
return
async def list_multipart_uploads(self, bucket: str, prefix: str = ""):
resp = await self._request("GET", f"/{bucket}", query={"uploads": "", "prefix": prefix})
root = ET.fromstring(await resp.aread())
out = []
for u in root.iter(NS + "Upload"):
out.append({"key": u.findtext(NS + "Key"), "upload_id": u.findtext(NS + "UploadId"),
"initiated": u.findtext(NS + "Initiated")})
return out
async def abort_multipart(self, bucket: str, key: str, upload_id: str) -> None:
resp = await self._request("DELETE", f"/{bucket}/{key}", query={"uploadId": upload_id})
await resp.aclose()
# ---------------------------------------------------------------- buckets
async def head_bucket(self, bucket: str) -> bool:
resp = await self._request("HEAD", f"/{bucket}")
await resp.aclose()
return resp.status_code != 404
async def create_bucket(self, bucket: str) -> bool:
"""True — создан, False — уже существовал (идемпотентно)."""
try:
resp = await self._request("PUT", f"/{bucket}")
await resp.aclose()
return True
except S3Error as exc:
if exc.code in ("BucketAlreadyOwnedByYou", "BucketAlreadyExists"):
return False
raise
+93
View File
@@ -0,0 +1,93 @@
"""Password KDF (scrypt из OpenSSL через hashlib) и opaque-токены сессий.
Пароль хешируется медленным memory-hard KDF с солью: цель — сделать перебор украденных
hash дорогим. Токен сессии уже содержит 256 бит случайности, перебирать его бессмысленно,
поэтому для индекса в БД/кэше достаточно быстрого SHA-256 — это разные задачи.
"""
from __future__ import annotations
import asyncio
import base64
import hashlib
import hmac
import secrets
_PREFIX = "$scrypt$"
def _b64(data: bytes) -> str:
return base64.b64encode(data).decode("ascii").rstrip("=")
def _unb64(text: str) -> bytes:
return base64.b64decode(text + "=" * (-len(text) % 4), validate=True)
class PasswordHasher:
"""Формат PHC-подобный: $scrypt$ln=15,r=8,p=3$<salt>$<hash>. Параметры хранятся в строке,
поэтому их можно усилить позднее без потери старых hash."""
def __init__(self, log2_n: int, r: int, p: int, concurrency: int):
self.log2_n, self.r, self.p = log2_n, r, p
# Ограничиваем одновременные KDF: каждый вызов занимает 128*r*N байт RAM (32 MiB при ln=15).
self._slots = asyncio.Semaphore(concurrency)
self._dummy: str | None = None
def _maxmem(self, log2_n: int, r: int, p: int) -> int:
return 128 * r * (2 ** log2_n) * 2 + 1024 * 1024 * p
def _derive(self, password: str, salt: bytes, log2_n: int, r: int, p: int) -> bytes:
return hashlib.scrypt(password.encode("utf-8"), salt=salt, n=2 ** log2_n, r=r, p=p,
maxmem=self._maxmem(log2_n, r, p), dklen=32)
def hash_sync(self, password: str) -> str:
salt = secrets.token_bytes(16)
digest = self._derive(password, salt, self.log2_n, self.r, self.p)
return f"{_PREFIX}ln={self.log2_n},r={self.r},p={self.p}${_b64(salt)}${_b64(digest)}"
def verify_sync(self, password: str, encoded: str) -> bool:
try:
if not encoded.startswith(_PREFIX):
return False
params, salt_b64, hash_b64 = encoded[len(_PREFIX):].split("$")
fields = dict(item.split("=", 1) for item in params.split(","))
log2_n, r, p = int(fields["ln"]), int(fields["r"]), int(fields["p"])
if not (10 <= log2_n <= 22 and 1 <= r <= 32 and 1 <= p <= 16):
return False
expected = _unb64(hash_b64)
actual = self._derive(password, _unb64(salt_b64), log2_n, r, p)
except (ValueError, KeyError):
return False
return hmac.compare_digest(actual, expected)
async def hash(self, password: str) -> str:
async with self._slots:
return await asyncio.to_thread(self.hash_sync, password)
async def verify(self, password: str, encoded: str | None) -> bool:
"""Для неизвестного пользователя проверяем фиктивный hash: время ответа не выдаёт,
существует ли username."""
if encoded is None:
if self._dummy is None:
self._dummy = await self.hash("dummy-password-for-timing")
encoded, password = self._dummy, password + "\x00never"
async with self._slots:
await asyncio.to_thread(self.verify_sync, password, encoded)
return False
async with self._slots:
return await asyncio.to_thread(self.verify_sync, password, encoded)
TOKEN_BYTES = 32 # 256 бит энтропии
def new_token() -> str:
return secrets.token_urlsafe(TOKEN_BYTES) # 43 символа base64url
def token_hash(token: str) -> bytes:
return hashlib.sha256(token.encode("ascii")).digest()
def looks_like_token(token: str) -> bool:
return len(token) == 43 and all(c.isascii() and (c.isalnum() or c in "-_") for c in token)
+185
View File
@@ -0,0 +1,185 @@
"""Сессии: PostgreSQL — источник истины, Redis/Valkey — read-through кэш с TTL.
Политика (подробно — REPORT.md):
* ключ sess:v1:<sha256(token)> хранит {user, expires_at}; TTL = min(SESSION_CACHE_TTL_SECONDS,
остаток жизни сессии) — кэш никогда не переживает срок сессии;
* logout: revoked_at + строка outbox в одной транзакции PostgreSQL, затем в Redis атомарно
«надгробие» sess:v1:revoked:<hash> и DEL ключа. Заполнение кэша — Lua SET … только если
надгробия нет, поэтому конкурентный read-through не вернёт отозванную сессию в кэш;
* Redis недоступен → аутентификация идёт в PostgreSQL (fail-open только к источнику истины,
не к анонимному доступу); после ошибки кэш не читается, пока фоновый цикл не проверит Redis
и не дообработает outbox инвалидаций;
* flush/restart Redis = холодный кэш: сессии остаются в PostgreSQL.
"""
from __future__ import annotations
import asyncio
import json
import logging
import time
from dataclasses import dataclass
from psycopg_pool import AsyncConnectionPool
from redis import asyncio as aioredis
from redis.exceptions import RedisError
from .config import Settings
log = logging.getLogger("messenger.sessions")
KEY = "sess:v1:"
TOMBSTONE = "sess:v1:revoked:"
# KEYS[1]=session key, KEYS[2]=tombstone; ARGV[1]=value, ARGV[2]=ttl ms
_SET_IF_NOT_REVOKED = """
if redis.call('EXISTS', KEYS[2]) == 1 then return 0 end
redis.call('SET', KEYS[1], ARGV[1], 'PX', ARGV[2])
return 1
"""
# KEYS[1]=session key, KEYS[2]=tombstone; ARGV[1]=tombstone ttl ms
_INVALIDATE = """
redis.call('SET', KEYS[2], '1', 'PX', ARGV[1])
redis.call('DEL', KEYS[1])
return 1
"""
@dataclass
class Principal:
user: dict
expires_at: float # epoch seconds
token_hash: bytes
class SessionCache:
def __init__(self, settings: Settings):
self.settings = settings
self.client: aioredis.Redis | None = None
self._set_script = None
self._invalidate_script = None
# degraded=True: кэш не читаем (было исключение Redis или есть недообработанный outbox).
self.degraded = True
self._next_probe = 0.0
self.stats = {"hits": 0, "misses": 0, "errors": 0}
if settings.cache_url:
t = settings.cache_timeout_seconds
self.client = aioredis.from_url(
settings.cache_url, socket_timeout=t, socket_connect_timeout=t,
retry_on_timeout=False, health_check_interval=0, max_connections=50,
decode_responses=False)
self._set_script = self.client.register_script(_SET_IF_NOT_REVOKED)
self._invalidate_script = self.client.register_script(_INVALIDATE)
@property
def enabled(self) -> bool:
return self.client is not None
def _tombstone_ms(self) -> int:
# Надгробие живёт дольше любой записи кэша и любого запроса в полёте.
return int((self.settings.session_cache_ttl_seconds + self.settings.request_timeout_seconds + 5) * 1000)
def _fail(self, op: str, exc: Exception) -> None:
self.stats["errors"] += 1
if not self.degraded:
log.warning("cache unavailable; falling back to PostgreSQL",
extra={"op": op, "error": type(exc).__name__})
self.degraded = True
self._next_probe = time.monotonic() + self.settings.cache_retry_seconds
async def get(self, th: bytes) -> Principal | None:
if not self.client or self.degraded:
return None
try:
raw = await self.client.get(KEY + th.hex())
except (RedisError, OSError, asyncio.TimeoutError) as exc:
self._fail("get", exc)
return None
if raw is None:
self.stats["misses"] += 1
return None
try:
data = json.loads(raw)
principal = Principal(user=data["user"], expires_at=float(data["exp"]), token_hash=th)
except (ValueError, KeyError, TypeError):
return None
if principal.expires_at <= time.time():
return None
self.stats["hits"] += 1
return principal
async def put(self, p: Principal) -> None:
if not self.client or self.degraded:
return
ttl_ms = int(min(self.settings.session_cache_ttl_seconds, p.expires_at - time.time()) * 1000)
if ttl_ms < 1:
return
value = json.dumps({"user": p.user, "exp": p.expires_at}, separators=(",", ":"))
try:
await self._set_script(keys=[KEY + p.token_hash.hex(), TOMBSTONE + p.token_hash.hex()],
args=[value, ttl_ms])
except (RedisError, OSError, asyncio.TimeoutError) as exc:
self._fail("put", exc)
async def invalidate(self, th: bytes) -> bool:
if not self.client:
return True
try:
await self._invalidate_script(keys=[KEY + th.hex(), TOMBSTONE + th.hex()],
args=[self._tombstone_ms()])
return True
except (RedisError, OSError, asyncio.TimeoutError) as exc:
self._fail("invalidate", exc)
return False
async def ping(self) -> bool:
if not self.client:
return False
try:
return bool(await self.client.ping())
except (RedisError, OSError, asyncio.TimeoutError):
return False
async def drain_outbox(self, pool: AsyncConnectionPool) -> int:
"""Повторяет инвалидации из session_cache_invalidations. True-результат: outbox пуст."""
drained = 0
while True:
async with pool.connection() as conn:
rows = await (await conn.execute(
"SELECT token_hash FROM session_cache_invalidations ORDER BY created_at LIMIT 500"
)).fetchall()
if not rows:
return drained
done = []
for row in rows:
th = bytes(row["token_hash"])
if not await self.invalidate(th):
raise ConnectionError("cache still unavailable")
done.append(th)
async with pool.connection() as conn:
await conn.execute("DELETE FROM session_cache_invalidations WHERE token_hash = ANY(%s)", (done,))
drained += len(done)
async def maintenance_loop(self, pool: AsyncConnectionPool, stop: asyncio.Event) -> None:
"""Возвращает кэш в работу только после успешного PING и пустого outbox."""
while not stop.is_set():
if self.client and time.monotonic() >= self._next_probe:
try:
if await self.ping():
drained = await self.drain_outbox(pool)
if self.degraded:
log.info("cache available again", extra={"replayed_invalidations": drained})
self.degraded = False
else:
self._fail("probe", ConnectionError("ping failed"))
except ConnectionError as exc:
self._fail("drain", exc)
except Exception as exc: # noqa: BLE001 — БД недоступна: состояние кэша не меняем
log.warning("outbox drain skipped", extra={"error": type(exc).__name__})
try:
await asyncio.wait_for(stop.wait(), timeout=1.0)
except asyncio.TimeoutError:
pass
async def close(self) -> None:
if self.client:
await self.client.aclose()
+119
View File
@@ -0,0 +1,119 @@
"""Строгая валидация входа: лишние поля, неверные типы и malformed JSON — 400."""
from __future__ import annotations
import base64
import json
import re
import uuid
from datetime import datetime
from .errors import ApiError, invalid
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}")
def _no_duplicates(pairs):
obj = {}
for key, value in pairs:
if key in obj:
raise ValueError("duplicate key")
obj[key] = value
return obj
def _reject_constant(name):
raise ValueError("non-standard JSON constant " + name)
def parse_json_object(raw: bytes, allowed: set[str], required: set[str]) -> dict:
if not raw:
raise invalid("Ожидается JSON-объект")
try:
data = json.loads(raw.decode("utf-8"), object_pairs_hook=_no_duplicates,
parse_constant=_reject_constant)
except (UnicodeDecodeError, ValueError, RecursionError):
raise invalid("Некорректный JSON") from None
if not isinstance(data, dict):
raise invalid("Ожидается JSON-объект")
extra = set(data) - allowed
if extra:
raise invalid("Лишние поля: " + ", ".join(sorted(extra))[:200])
missing = required - set(data)
if missing:
raise invalid("Отсутствуют поля: " + ", ".join(sorted(missing)))
return data
def text_field(data: dict, name: str, lo: int, hi: int) -> str:
value = data.get(name)
if not isinstance(value, str):
raise invalid(f"Поле {name} должно быть строкой")
if not lo <= len(value) <= hi: # len() в Python — число Unicode code points
raise invalid(f"Поле {name}: длина {lo}–{hi} символов")
if lo > 0 and not value.strip():
raise invalid(f"Поле {name} не может состоять только из пробелов")
if "\x00" in value:
raise invalid(f"Поле {name} содержит недопустимый символ")
try:
value.encode("utf-8")
except UnicodeEncodeError: # одиночные суррогаты из \uD800-escape
raise invalid(f"Поле {name} содержит некорректный Unicode") from None
return value
def parse_uuid(value, what: str = "UUID") -> uuid.UUID:
if not isinstance(value, str):
raise invalid(f"Некорректный {what}")
try:
parsed = uuid.UUID(value)
except ValueError:
raise invalid(f"Некорректный {what}") from None
# Принимаем только каноническую 36-символьную запись (без {} и urn:).
if len(value) != 36:
raise invalid(f"Некорректный {what}")
return parsed
def parse_limit(params) -> int:
values = params.getlist("limit")
if not values:
return 50
if len(values) > 1 or not values[0].isascii() or not values[0].isdigit() or len(values[0]) > 3:
raise invalid("limit должен быть целым 1–100")
limit = int(values[0])
if not 1 <= limit <= 100:
raise invalid("limit должен быть целым 1–100")
return limit
def single_param(params, name: str) -> str | None:
values = params.getlist(name)
if len(values) > 1:
raise invalid(f"Параметр {name} указан несколько раз")
return values[0] if values else None
# --- keyset cursor -------------------------------------------------------------------------
# Курсор непрозрачен для клиента: base64url(JSON) с видом списка и областью (чат/пользователь).
# Подделка курсора не даёт доступа: область всё равно проверяется, а позиция лишь фильтр.
def encode_cursor(kind: str, scope: uuid.UUID, created_at: datetime, item_id: uuid.UUID) -> str:
payload = json.dumps({"v": 1, "k": kind, "s": str(scope), "t": created_at.isoformat(), "i": str(item_id)},
separators=(",", ":")).encode()
return base64.urlsafe_b64encode(payload).decode().rstrip("=")
def decode_cursor(cursor: str, kind: str, scope: uuid.UUID) -> tuple[datetime, uuid.UUID]:
try:
if not cursor or len(cursor) > 512 or not cursor.isascii():
raise ValueError
raw = base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4))
data = json.loads(raw)
if data.get("v") != 1 or data.get("k") != kind or data.get("s") != str(scope):
raise ValueError
ts = datetime.fromisoformat(data["t"])
if ts.tzinfo is None:
raise ValueError
return ts, uuid.UUID(data["i"])
except (ValueError, KeyError, TypeError, AttributeError, UnicodeError):
raise ApiError("invalid_request", "Некорректный cursor") from None
+158
View File
@@ -0,0 +1,158 @@
"""Общая обвязка собственных проверок студента (stdlib, Python 3.9+).
Переиспользует HTTP-клиент публичных тестов (tests/client.py), не изменяя его. Команды управления
стендом и доступа к SQL задаются переменными окружения; по умолчанию — Compose из этого репозитория.
"""
import base64
import hashlib
import json
import os
import shlex
import subprocess
import sys
import time
import traceback
import uuid
import zlib
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, Failure, check # noqa: E402
DC = os.environ.get("COMPOSE", "docker compose --env-file .env")
PSQL = os.environ.get("PSQL", DC + " exec -T postgres psql -U messenger -d messenger")
COMMANDS = {
"stop_db": os.environ.get("STOP_DB", DC + " stop postgres"),
"start_db": os.environ.get("START_DB", DC + " start postgres"),
"stop_cache": os.environ.get("STOP_CACHE", DC + " stop redis"),
"start_cache": os.environ.get("START_CACHE", DC + " start redis"),
}
BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080")
TTL_BASE_URL = os.environ.get("TTL_BASE_URL", "http://127.0.0.1:8081")
TTL_SECONDS = float(os.environ.get("TTL_SECONDS", "2"))
def sh(name_or_cmd, timeout=90):
cmd = COMMANDS.get(name_or_cmd, name_or_cmd)
subprocess.run(shlex.split(cmd), cwd=ROOT, check=True, timeout=timeout,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
def sql(query):
"""Одна SQL-команда через psql (-At); возвращает строки результата. Только синтетические данные."""
out = subprocess.run(shlex.split(PSQL) + ["-X", "-At", "-v", "ON_ERROR_STOP=1", "-c", query],
cwd=ROOT, check=True, capture_output=True, text=True, timeout=60)
return [line for line in out.stdout.splitlines() if line]
S3_ADMIN = os.environ.get("S3_ADMIN", DC + " run --rm --no-deps -T --entrypoint python s3-init -")
API_EXEC = os.environ.get("API_EXEC", DC + " exec -T api")
def s3_admin(op, key, data=None):
"""Операция с bucket admin-ключом В ОБХОД API (внедрение отказов на стороне S3)."""
args = [op, key] + ([base64.b64encode(data).decode()] if data is not None else [])
script = (ROOT / "student-tests" / "s3_admin.py").read_bytes()
out = subprocess.run(shlex.split(S3_ADMIN) + args, cwd=ROOT, input=script, capture_output=True,
check=True, timeout=120)
return out.stdout.decode().strip()
def reconcile(*args, expect=(0, 2)):
"""python -m messenger reconcile внутри API-контейнера; возвращает (код выхода, JSON-отчёт)."""
out = subprocess.run(shlex.split(API_EXEC) + ["python", "-m", "messenger", "reconcile", "--samples", "100000"]
+ list(args), cwd=ROOT, capture_output=True, text=True, timeout=600)
if out.returncode not in expect:
raise Failure("reconcile exit %d: %s" % (out.returncode, out.stderr.strip()[-300:]))
return out.returncode, json.loads(out.stdout)
def make_png(width=16, height=16, seed=None):
"""Валидный RGB PNG (stdlib), уникальный по seed — для разных SHA-256."""
seed = seed if seed is not None else uuid.uuid4().bytes
rnd = hashlib.sha256(seed).digest()
rows = b"".join(b"\x00" + bytes((rnd[(x + y) % 32] ^ x ^ y) & 0xFF for x in range(width * 3)) for y in range(height))
def chunk(t, d):
return len(d).to_bytes(4, "big") + t + d + zlib.crc32(t + d).to_bytes(4, "big")
ihdr = width.to_bytes(4, "big") + height.to_bytes(4, "big") + bytes([8, 2, 0, 0, 0])
return b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr) + chunk(b"IDAT", zlib.compress(rows)) + chunk(b"IEND", b"")
def upload(c, actor, chat, data=None, content_type="image/png", filename="pic.png", expected=201, headers=None):
from urllib.parse import quote
data = make_png() if data is None else data
h = {"Content-Type": content_type}
h.update(headers or {})
r = c.call("POST", "/api/v1/chats/" + chat["id"] + "/attachments?filename=" + quote(filename), expected,
actor=actor, raw=data, headers=h, schema="Attachment" if expected == 201 else None)
return (r["json"], data) if expected == 201 else r
def basic(username, password):
return "Basic " + base64.b64encode((username + ":" + password).encode("utf-8")).decode()
def new_user(c, label="s", password=None):
username = ("st_" + label + "_" + uuid.uuid4().hex[:10])[:32]
password = password or ("Pw-" + uuid.uuid4().hex)
user = c.call("POST", "/api/v1/users", 201, schema="User",
body={"username": username, "display_name": "Тест " + label, "password": password})["json"]
return {"id": user["id"], "user": user, "username": username, "password": password}
def login(c, actor, expected=201):
r = c.call("POST", "/api/v1/auth/sessions", expected, headers={"Authorization": basic(actor["username"], actor["password"])},
schema="Session" if expected == 201 else None)
if expected == 201:
actor["token"] = r["json"]["token"]
actor["expires_at"] = r["json"]["expires_at"]
return r
def wait_until(probe, timeout=60, interval=0.5):
deadline = time.monotonic() + timeout
last = None
while time.monotonic() < deadline:
try:
if probe():
return time.monotonic()
except Failure as exc:
last = exc
time.sleep(interval)
raise Failure("condition not reached in %ss (%s)" % (timeout, last))
class Suite:
def __init__(self, name):
self.name, self.results = name, []
def case(self, title):
def decorator(fn):
self.results.append((title, fn))
return fn
return decorator
def run(self):
passed = failed = 0
print("## " + self.name)
for title, fn in self.results:
start = time.monotonic()
try:
note = fn()
passed += 1
print("PASS %-62s %6.2fs%s" % (title, time.monotonic() - start, (" " + note) if note else ""))
except Exception as exc: # noqa: BLE001
failed += 1
print("FAIL %-62s %s" % (title, exc))
if os.environ.get("DEBUG"):
traceback.print_exc()
print("summary: %d passed, %d failed" % (passed, failed))
raise SystemExit(1 if failed else 0)
__all__ = ["Client", "Failure", "check", "sh", "sql", "basic", "new_user", "login", "wait_until", "Suite",
"s3_admin", "reconcile", "make_png", "upload",
"BASE_URL", "TTL_BASE_URL", "TTL_SECONDS", "json"]

Some files were not shown because too many files have changed in this diff Show More