forked from mtusi2026/mtusi2026lab4
Lab 4: S3 attachments (SeaweedFS), streaming validation, compensation, reconciler (track 2)
This commit is contained in:
@@ -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)
|
||||
@@ -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
|
||||
MAX_UPLOAD_BYTES=10485760
|
||||
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
|
||||
@@ -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
@@ -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
|
||||
@@ -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"]
|
||||
@@ -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
|
||||
@@ -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).
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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."
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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'))
|
||||
);
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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
|
||||
@@ -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/"
|
||||
@@ -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).'
|
||||
@@ -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)."
|
||||
@@ -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
|
||||
}
|
||||
@@ -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%
|
||||
Executable → Regular
@@ -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
|
||||
}
|
||||
@@ -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"
|
||||
@@ -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"
|
||||
@@ -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 }
|
||||
@@ -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 ]
|
||||
@@ -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%
|
||||
Executable → Regular
@@ -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
|
||||
@@ -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"
|
||||
@@ -0,0 +1,2 @@
|
||||
"""MTUSI messenger API, lab3."""
|
||||
__version__ = "3.0.0"
|
||||
@@ -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())
|
||||
@@ -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"]
|
||||
@@ -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", ""),
|
||||
)
|
||||
@@ -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)
|
||||
@@ -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"})
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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
|
||||
@@ -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
Reference in New Issue
Block a user