forked from mtusi2026/mtusi2026lab4
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
081d0fd2c8 | ||
|
|
445cfe4789 |
@@ -18,3 +18,20 @@ __pycache__
|
||||
node_modules
|
||||
evidence
|
||||
.DS_Store
|
||||
.pytest_cache
|
||||
*.py[cod]
|
||||
tests
|
||||
student-tests
|
||||
contracts
|
||||
scripts
|
||||
examples
|
||||
docs
|
||||
*.md
|
||||
Makefile
|
||||
Dockerfile*
|
||||
requirements-dev.txt
|
||||
lab.json
|
||||
.mypy_cache
|
||||
.ruff_cache
|
||||
infra
|
||||
.venv-validate
|
||||
|
||||
+47
-5
@@ -3,14 +3,40 @@
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
LOG_LEVEL=INFO
|
||||
SHUTDOWN_TIMEOUT_SEC=5
|
||||
|
||||
SHUTDOWN_DRAIN_SEC=1
|
||||
APP_KEEPALIVE_TIMEOUT_SEC=75
|
||||
|
||||
DB_USER=test
|
||||
DB_PASS=test
|
||||
DB_NAME=test
|
||||
DB_HOST=localhost
|
||||
DB_PORT=5432
|
||||
DB_POOL_MIN_SIZE=2
|
||||
DB_POOL_MAX_SIZE=10
|
||||
DB_CONNECT_TIMEOUT_SEC=3
|
||||
DB_COMMAND_TIMEOUT_SEC=5
|
||||
DB_STARTUP_TIMEOUT_SEC=30
|
||||
|
||||
VALKEY_HOST=localhost
|
||||
VALKEY_PORT=6379
|
||||
VALKEY_PASS=test
|
||||
VALKEY_POOL_MAX_SIZE=20
|
||||
VALKEY_TIMEOUT_SEC=0.5
|
||||
VALKEY_RETRY_AFTER_SEC=5
|
||||
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
SESSION_CACHE_TTL_SECONDS=60
|
||||
PASSWORD_HASH_WORKERS=4
|
||||
|
||||
# lab3: число API-реплик за балансировщиком и срок хранения Idempotency-Key
|
||||
API_REPLICAS=2
|
||||
# Публичный порт балансировщика на 127.0.0.1 (порт для make test-expiry — LB_EXPIRY_PORT=8081)
|
||||
LB_PORT=8080
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
|
||||
S3_ENDPOINT=http://s3:9000
|
||||
S3_REGION=us-east-1
|
||||
S3_BUCKET=messenger-attachments
|
||||
@@ -18,3 +44,19 @@ 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
|
||||
# Только путь к файлам; сами ключи — в secrets/ (scripts/init-secrets.sh)
|
||||
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_POOL_MAX_SIZE=20
|
||||
S3_CONNECT_TIMEOUT_SEC=2
|
||||
S3_READ_TIMEOUT_SEC=10
|
||||
S3_MAX_ATTEMPTS=2
|
||||
S3_STARTUP_TIMEOUT_SEC=60
|
||||
# Байт загрузки в RAM; остальное — во временном файле запроса (удаляется сразу)
|
||||
UPLOAD_SPOOL_MEMORY_BYTES=1048576
|
||||
# Одновременных проверок изображений на реплику: худший случай ~250 МБ на одну
|
||||
IMAGE_INSPECT_WORKERS=1
|
||||
ATTACHMENT_STORE_TIMEOUT_SEC=30
|
||||
# Janitor очищает незавершённые загрузки не моложе grace period
|
||||
ATTACHMENT_PENDING_GRACE_SEC=900
|
||||
JANITOR_INTERVAL_SEC=60
|
||||
|
||||
@@ -30,3 +30,7 @@ coverage/
|
||||
.vscode/
|
||||
# Keep small, sanitized evidence summaries in evidence/ under version control.
|
||||
# Inspect git diff --cached: ignore rules are not a secret scanner.
|
||||
.pytest_cache/
|
||||
.mypy_cache/
|
||||
.ruff_cache/
|
||||
.venv-validate/
|
||||
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
FROM python:3.12.12-slim-bookworm
|
||||
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
POETRY_VIRTUALENVS_CREATE=false
|
||||
|
||||
WORKDIR /app
|
||||
COPY poetry.lock pyproject.toml ./
|
||||
RUN pip install --no-cache-dir --timeout 60 --retries 10 "poetry==2.2.1" \
|
||||
&& poetry install --only main --no-root --no-interaction
|
||||
COPY migrations ./migrations
|
||||
COPY src ./src
|
||||
|
||||
# Процесс работает не от root
|
||||
RUN useradd --system --uid 10001 --no-create-home app
|
||||
USER app
|
||||
|
||||
ARG APP_REVISION=dev
|
||||
ENV APP_REVISION=${APP_REVISION}
|
||||
LABEL org.opencontainers.image.revision=${APP_REVISION}
|
||||
|
||||
EXPOSE 8080
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
|
||||
CMD ["python", "src/healthcheck.py"]
|
||||
CMD ["python", "src/gateway.py"]
|
||||
@@ -4,10 +4,19 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence test-failover
|
||||
export BUILDX_NO_DEFAULT_ATTESTATIONS := 1
|
||||
|
||||
.PHONY: help check validate test load test-persistence test-failover install init up down restart restore instances rolling-update ps logs wait-ready destroy-data student-test concurrency-test test-expiry test-failures test-migrations explain sigterm-check experiment-failover experiment-rolling test-storage test-s3-failure janitor-dry-run janitor-once experiment-uploads s3-ui
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "up/down/restart/ps/logs: compose stack; destroy-data: DELETE volumes intentionally"
|
||||
@echo "instances: API containers <-> X-Instance-Id; restore: start replicas stopped by stop-one.sh; rolling-update: replace replicas one by one"
|
||||
@echo "experiment-failover / experiment-rolling: load + stop each replica / rolling update, metrics to evidence/"
|
||||
@echo "student-test: own tests; test-migrations: from empty volume; test-expiry: short SESSION_TTL; test-failures: stop Valkey/PostgreSQL/S3; explain: EXPLAIN history"
|
||||
@echo "init: .env + local S3 secrets; test-storage: private bucket/credentials/consistency; janitor-dry-run / janitor-once: S3/DB reconcile"
|
||||
@echo "experiment-uploads: >=10 concurrent uploads, peak API memory to evidence/"
|
||||
@echo "s3-ui: temporary read-only SeaweedFS Filer UI on 127.0.0.1:8888 (Ctrl+C to close)"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -28,3 +37,92 @@ test-persistence:
|
||||
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)
|
||||
|
||||
install:
|
||||
poetry install --no-root
|
||||
|
||||
init:
|
||||
./scripts/init-secrets.sh
|
||||
|
||||
up:
|
||||
docker compose up -d --build --wait
|
||||
|
||||
down:
|
||||
docker compose --profile expiry down
|
||||
|
||||
restart:
|
||||
./scripts/restart.sh
|
||||
@$(MAKE) --no-print-directory wait-ready
|
||||
|
||||
restore:
|
||||
./scripts/restore.sh
|
||||
|
||||
instances:
|
||||
./scripts/instances.sh
|
||||
|
||||
rolling-update:
|
||||
./scripts/rolling-update.sh
|
||||
|
||||
ps:
|
||||
docker compose ps
|
||||
|
||||
logs:
|
||||
docker compose logs -f api nginx
|
||||
|
||||
wait-ready:
|
||||
@for i in $$(seq 1 60); do \
|
||||
curl -fsS "$(BASE_URL)/health/ready" >/dev/null 2>&1 && echo "ready: $(BASE_URL)" && exit 0; \
|
||||
sleep 1; \
|
||||
done; echo "API is not ready after 60s"; exit 1
|
||||
|
||||
destroy-data:
|
||||
docker compose --profile expiry down -v
|
||||
|
||||
student-test:
|
||||
BASE_URL="$(BASE_URL)" poetry run pytest
|
||||
|
||||
concurrency-test:
|
||||
BASE_URL="$(BASE_URL)" poetry run pytest student-tests/test_concurrency.py -s
|
||||
|
||||
test-expiry:
|
||||
docker compose --profile expiry up -d --build --wait api-short-ttl
|
||||
EXPIRY_BASE_URL=http://localhost:8081 poetry run pytest student-tests/test_expiry.py -s; \
|
||||
status=$$?; docker compose --profile expiry stop api-short-ttl; exit $$status
|
||||
|
||||
test-failures:
|
||||
BASE_URL="$(BASE_URL)" RUN_FAILURE_TESTS=1 poetry run pytest student-tests/test_dependency_failures.py student-tests/test_storage_failures.py student-tests/test_attachment_failover.py -s
|
||||
|
||||
test-s3-failure:
|
||||
BASE_URL="$(BASE_URL)" RUN_FAILURE_TESTS=1 poetry run pytest student-tests/test_storage_failures.py -s
|
||||
|
||||
test-storage:
|
||||
BASE_URL="$(BASE_URL)" RUN_STORAGE_TESTS=1 poetry run pytest student-tests/test_storage_security.py student-tests/test_storage_consistency.py -s
|
||||
|
||||
janitor-dry-run:
|
||||
docker compose exec -T janitor python src/janitor.py --once --dry-run
|
||||
|
||||
janitor-once:
|
||||
docker compose exec -T janitor python src/janitor.py --once
|
||||
|
||||
s3-ui:
|
||||
$(PYTHON) scripts/s3_ui.py
|
||||
|
||||
experiment-uploads:
|
||||
poetry run python scripts/upload_experiment.py --base-url "$(BASE_URL)" --output evidence/experiment-uploads.json
|
||||
|
||||
test-migrations:
|
||||
./scripts/check_migrations.sh
|
||||
|
||||
explain:
|
||||
docker compose exec -T postgres sh -c 'psql -X -q -v ON_ERROR_STOP=1 -U "$$POSTGRES_USER" -d "$$POSTGRES_DB"' \
|
||||
< scripts/explain_history.sql > evidence/explain_history.txt
|
||||
@echo "saved: evidence/explain_history.txt"
|
||||
|
||||
sigterm-check:
|
||||
$(PYTHON) scripts/sigterm_check.py --base-url "$(BASE_URL)"
|
||||
|
||||
experiment-failover:
|
||||
$(PYTHON) scripts/experiment.py failover --base-url "$(BASE_URL)" --output evidence/experiment-failover.json
|
||||
|
||||
experiment-rolling:
|
||||
$(PYTHON) scripts/experiment.py rolling --base-url "$(BASE_URL)" --output evidence/experiment-rolling.json
|
||||
|
||||
@@ -1,37 +1,138 @@
|
||||
# Отчёт — лабораторная 4
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Саватеев Артём, группа TODO
|
||||
- Целевая оценка: **4**; трек 5 не заявлен
|
||||
- Commit/PR: TODO после публикации (ветка `feature/lab4-core-logic`)
|
||||
- Использованные источники, библиотеки и помощь ИИ: FastAPI, asyncpg, redis-py, aiobotocore 3.9.1 (S3-клиент), Pillow 12.3.0 (проверка изображений), SeaweedFS 4.48 (S3-сервер); документация S3 API и SeaweedFS (identities, `-s3.config`)
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Prerequisites: Docker Engine 29 / Compose v2.40, Python 3.12 + Poetry 2.2 (для собственных тестов), Python 3.9+ (публичные тесты)
|
||||
|
||||
| Компонент | Образ / версия |
|
||||
| --- | --- |
|
||||
| API, migrate, s3-bootstrap, janitor | `mtusi-messenger:lab4` из `Dockerfile` (python:3.12.12-slim-bookworm) |
|
||||
| PostgreSQL | `postgres:18.2-alpine3.22` |
|
||||
| Valkey | `valkey/valkey:8.1.4-alpine3.22` |
|
||||
| S3 | `chrislusf/seaweedfs:4.48` |
|
||||
| LB | `nginx:1.28.0-alpine3.21` |
|
||||
|
||||
```sh
|
||||
make init # .env из .env.example + секреты в secrets/ (повторный запуск ничего не меняет)
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build --wait
|
||||
# порядок: postgres, valkey, s3 → migrate (миграции) и s3-bootstrap (bucket)
|
||||
# → api ×2, janitor → nginx; --wait ждёт healthy всех сервисов
|
||||
make test # публичный smoke
|
||||
make install && make student-test # собственные unit + black-box тесты
|
||||
make test-storage # приватность bucket, права ключей, сверка janitor
|
||||
make test-failures # отказы PostgreSQL/Valkey/S3 и реплики, принявшей файл
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && ./scripts/restore.sh
|
||||
make experiment-uploads # ≥10 одновременных загрузок, пик памяти → evidence/
|
||||
make test-migrations # миграции с пустого volume (отдельный compose-проект)
|
||||
```
|
||||
|
||||
Безопасная остановка: `make down` (volumes сохраняются). Намеренное удаление учебных данных: `make destroy-data` (`down -v`: PostgreSQL и S3). Секреты: `scripts/init-secrets.sh` создаёт `secrets/` (в `.gitignore`), значения не печатает и не перезаписывает — иначе объекты bucket станут недоступны. Оператору больше ничего делать не нужно: bucket создаётся сервисом `s3-bootstrap` автоматически.
|
||||
|
||||
Если порт 8080 занят другим стендом (например, lab3), задайте `LB_PORT` в `.env` и `BASE_URL=http://localhost:<порт>` для тестов.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
клиент → nginx (edge) → api ×2 ─┬─ backend: PostgreSQL (метаданные, источник истины), Valkey (кэш сессий)
|
||||
└─ storage: SeaweedFS S3 (байты оригиналов, приватный bucket)
|
||||
janitor (backend + storage): сверка S3/БД
|
||||
migrate, s3-bootstrap: одноразовые, до старта API
|
||||
```
|
||||
|
||||
**Перенесено из lab3 без изменений:** пользователи, сессии (PostgreSQL + Valkey), чаты, история, Idempotency-Key, 2 реплики за nginx, graceful shutdown, `X-Instance-Id`, скрипты отказов. **Изменено:** сообщение получило `attachment_ids` (пустой текст разрешён только с вложениями); hash идемпотентности считается без полей по умолчанию, поэтому для текстовых сообщений он совпадает с lab3. Попутно исправлен Makefile lab3: потерянная строка цели `test-expiry`.
|
||||
|
||||
**Слои** (как в lab3): `domain` (схемы, ошибки) → `interfaces` (абстракции `AttachmentRepository`, `ObjectStorage`) → `infrastructure` (PostgreSQL/S3 реализации, `AttachmentService`, `StorageReconciler`, `ImageInspector`) → `application` (FastAPI endpoints). Сервисы зависят только от интерфейсов, поэтому отказы S3/БД проверяются unit-тестами на фейках.
|
||||
|
||||
**Хранилище.** MinIO не выбран: образы `minio/minio` и `minio/mc` больше не скачиваются из Docker Hub/quay, стенд не собрался бы из чистого clone. SeaweedFS 4.48 запускается одним контейнером `weed server`:
|
||||
- master/volume/filer и их веб-интерфейсы слушают только `127.0.0.1` внутри контейнера; в сеть `storage` открыт лишь S3 API `:9000`. Порты наружу не публикуются, сеть `storage` — `internal`, в неё входят только api, janitor, s3-bootstrap.
|
||||
- Identities (`secrets/s3_identities.json`): `bootstrap` (Admin) — только у `s3-bootstrap`; `messenger-api` — `Read/Write/List` **только своего bucket** — у API и janitor. Identity `anonymous` нет, поэтому любой неподписанный запрос получает 403.
|
||||
- `s3-bootstrap` идемпотентен: `CreateBucket` с обработкой `BucketAlreadyOwnedByYou`, затем проверяет, что анонимный запрос получает 403. Иначе завершается ошибкой, и API не стартует.
|
||||
|
||||
**Модель данных** (`migrations/0003_attachments.sql`): `attachments` (метаданные + `object_key` + `status` pending/ready/deleting), `message_attachments` (порядок вложений). Составные FK гарантируют на уровне БД, что владелец — участник чата, а вложение и сообщение принадлежат одному чату. Используемое вложение удалить нельзя (FK без CASCADE). Ключ объекта `originals/<128 бит random>` назначает сервер; `filename` — только отображение.
|
||||
|
||||
**Загрузка** `POST /chats/{id}/attachments` (сырые байты):
|
||||
1. Аутентификация → членство в чате (404) → filename (400) → Content-Type (415) → Content-Length > 10 MiB (413). Всё это до чтения тела.
|
||||
2. Тело читается потоком: первые 1 MiB в RAM, остальное во временный файл запроса, который удаляется сразу. Чтение обрывается на байте 10 MiB+1 (413). SHA-256 считается по ходу.
|
||||
3. `ImageInspector` в пуле из `IMAGE_INSPECT_WORKERS` потоков: формат по сигнатуре (подмена MIME → 415); размеры из заголовка до распаковки (> 40 Мпикс → 413); целостность: PNG — CRC всех chunk и IEND, JPEG — декодирование libjpeg в draft-режиме 1/8 (повреждено → 415).
|
||||
4. Запись: строка `pending` (COMMIT) → один `PUT` в S3 с `x-amz-checksum-sha256` (S3 сверяет байты) → `pending → ready` → **201**. 201 возвращается только когда оригинал в S3 и метаданные подтверждены. PUT + подтверждение ограничены `ATTACHMENT_STORE_TIMEOUT_SEC=30`.
|
||||
|
||||
**Скачивание** — только через API, без redirect: проверка участника (чужое/неизвестное/незавершённое — одинаковый 404), затем поток из S3 по 64 KiB с истинным `Content-Type`, `Content-Length`, `X-Content-Type-Options: nosniff`, `Content-Disposition` (RFC 5987). Случайный ключ и приватный bucket не заменяют ACL: ключ мог бы утечь через логи или бэкап, а доступ к файлу определяется членством в чате, которое знает только приложение.
|
||||
|
||||
**Согласованность S3 ↔ PostgreSQL (уровень 4).** Инвариант: *у каждого объекта под `originals/` есть строка*. Строка коммитится до PUT, а удаляется только после удаления объекта.
|
||||
- Сбой после записи строки (S3 PUT упал или неизвестен, COMMIT `ready` не прошёл, таймаут, отмена задачи при остановке реплики) компенсируется сразу: `pending → deleting` → `DeleteObject` → `DELETE` строки. Строку сначала *забирают*: если UPDATE в `ready` на самом деле прошёл, claim не сработает, и объект готового вложения уцелеет.
|
||||
- Если компенсация не удалась (S3/БД недоступны, процесс убит), остаётся строка `pending` или `deleting`. Её дочищает **janitor** (`src/janitor.py`, отдельный сервис, раз в 60 с): `pending` старше `ATTACHMENT_PENDING_GRACE_SEC=900` атомарно переводится в `deleting` (`FOR UPDATE SKIP LOCKED`), затем удаляется объект (идемпотентно), затем строка. Прерванная очистка `deleting` повторяется при следующем проходе.
|
||||
- **Безопасность grace period:** API подтверждает только строку моложе grace (`created_at > now() - grace` по часам БД), janitor забирает только старше grace. Граничную гонку сериализует блокировка строки. Загрузка длится ≤ 30 с + проверка, что на порядки меньше 900 с.
|
||||
- Второй проход janitor — сверка bucket: объекты без строки старше grace удаляются. При соблюдении инварианта их нет; проход проверяет инвариант и страхует, например, от восстановления БД из старой копии. Свежие объекты и любые `ready` не трогаются. `--dry-run` только отчитывается.
|
||||
- **«S3 PUT прошёл, COMMIT нет»:** объект учтён строкой `pending`. Клиент получил 503 и id не знает. Компенсация удалит объект сразу, а если не сможет — janitor через ≤ grace + интервал.
|
||||
|
||||
**Readiness** = PostgreSQL + S3 (`head_bucket` с таймаутом 2 с): с lab4 вложения входят в обязательный синхронный путь. Valkey не критичен, как и раньше. При падении S3 реплика честно отвечает 503 на `/health/ready`. nginx не исключает реплики по readiness, поэтому сообщения, сессии и метаданные продолжают работать, а загрузка и скачивание отвечают быстрым 503.
|
||||
|
||||
**Лимиты памяти по всей цепочке:** nginx (`proxy_request_buffering off` на upload, `client_max_body_size 11m`: тело 10 MiB+1 отклоняет сама реплика с 413 по контракту), API (spool 1 MiB RAM на загрузку, проверка изображений в 1 потоке на реплику, лимит контейнера 512M), SeaweedFS (`-s3.concurrentUploadLimitMB=128`, `GOMEMLIMIT=384MiB`, лимит 512M). Последние два пункта — исправления по итогам эксперимента (см. ниже).
|
||||
|
||||
**Переменные `.env.example` → конфигурация:** `S3_ENDPOINT/REGION/BUCKET` → клиент aiobotocore (path-style); `S3_ACCESS_KEY_ID_FILE`/`S3_SECRET_ACCESS_KEY_FILE` → compose secrets `/run/secrets/*` у api и janitor; `S3_ADMIN_*_FILE` → только у s3-bootstrap; `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS` → лимиты контракта; `UPLOAD_SPOOL_MEMORY_BYTES`, `IMAGE_INSPECT_WORKERS` → память на загрузку; `S3_CONNECT/READ_TIMEOUT_SEC`, `S3_MAX_ATTEMPTS`, `ATTACHMENT_STORE_TIMEOUT_SEC` → ограниченное время ответа; `ATTACHMENT_PENDING_GRACE_SEC`, `JANITOR_INTERVAL_SEC` → janitor.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke | `make test` | PASS: lab4 public API scenario | `evidence/tests.txt` |
|
||||
| Lab3 сохранена | `make student-test` | 187 passed, 16 skipped (явные отказы и expiry запускаются своими целями) | `evidence/tests.txt` |
|
||||
| S3 в стенде, метаданные в PG, байты в приватном bucket | `compose.yaml`, `test_storage_security.py`, `test_attachments.py::test_public_api_does_not_expose_storage_details` | Объекты только в SeaweedFS (volume `s3_data`), на API нет volume. Ответ API не раскрывает ключ, bucket и адрес | `evidence/tests.txt` |
|
||||
| 201 ready, побайтный download, checksum, посторонний 404 | `test_attachments.py` (PNG fixture, JPEG baseline/progressive) | SHA-256 и байты совпадают у второго участника; посторонний и неизвестный id — одинаковый 404 | `evidence/tests.txt` |
|
||||
| Сообщение с `attachment_ids` | `test_message_attachments.py` | Читается участником, порядок сохранён, `text=""` с вложением → 201 | `evidence/tests.txt` |
|
||||
| PNG/JPEG ≤ 10 MiB, ≤ 40 Мпикс, MIME по содержимому, опасные имена | `test_attachments.py` | Ровно 10 485 760 байт → 201, +1 → 413 от API; 8000×5000 → 201, 8000×5001 → 413 (файл < 1 MiB, лимит до распаковки); 13 опасных filename → 400 | `evidence/tests.txt` |
|
||||
| Failover upload → download | `test_attachment_failover.py`, `make test-failover` ×2 | `UPLOADED BY 5a67…, DOWNLOADED FROM [da68…]`; публичный: 0 ошибок, восстановление записи 2.06 с и 1.62 с | `evidence/failures.txt`, `evidence/failover.txt` |
|
||||
| Restart с volumes | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS; uptime всех 7 контейнеров сброшен | `evidence/persistence.txt` |
|
||||
| **4:** слишком большой файл, повреждённое, подмена MIME, чужое id, файл другого чата, без 500 | `test_attachments.py`, `test_message_attachments.py` | 413 / 415 (6 видов повреждений, 9 видов подмены) / 404 / 404, сообщение не создаётся; каждый ответ проверен `assert_not_server_error` | `evidence/tests.txt` |
|
||||
| **4:** обрыв загрузки и отказ между S3/БД | `student-tests/unit/test_unit_attachment_service.py` (8 сценариев отказа на фейках), `test_storage_consistency.py` (стенд), `test_storage_failures.py` | Во всех сценариях итог — ни объектов, ни строк. На стенде janitor удалил 2 «упавшие» загрузки и 1 сироту, свежие и `ready` сохранены. Обрыв тела прямо в реплике — 0 строк | `evidence/tests.txt`, `evidence/failures.txt` |
|
||||
| **4:** RAM ограничена, ≥ 10 одновременных загрузок | `make experiment-uploads` | см. раздел «Эксперименты» | `evidence/experiment-uploads.json` |
|
||||
| **4:** идемпотентный bootstrap, отдельные ограниченные ключи, консоль закрыта, private bucket вне API | `make test-storage` (`test_storage_security.py`) | 2 запуска bootstrap: «уже существует», «приватен»; API-ключ: put/get/delete своего bucket — да, `CreateBucket/DeleteBucket/PutBucketPolicy/PutBucketAcl` — AccessDenied; у API нет админ-ключей; порты 9333/8888/8080/19333/18888/18080/8181/9101 закрыты; анонимный GET объекта, списка и сервиса — 403; nginx не видит S3 | `evidence/tests.txt` |
|
||||
| Миграции с нуля | `make test-migrations` | 0001–0003 применяются; 3 повторных запуска идемпотентны; API без migrate не стартует | вывод команды |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
**Гипотеза:** память API на загрузку ограничена (spool 1 MiB, потоковый PUT/GET, 1 поток декодирования на реплику), поэтому пик RSS не растёт как N × размер файла.
|
||||
|
||||
**Методика** (`scripts/upload_experiment.py`): 2 API-реплики (1 CPU / 512M каждая), Docker Desktop VM 10 CPU / 7.7 GiB, macOS arm64. Перед каждым раундом реплики перезапускаются, затем прогрев. N загрузок стартуют по одному барьеру через nginx. Память опрашивается внутри контейнеров каждые 0.2 с (VmRSS процесса, cgroup `memory.current`), плюс VmHWM. После раунда один файл скачивается и сверяется по SHA-256. Профили: PNG 9.19 MB из шума (приём тела, spool, S3) и progressive JPEG 8000×5000 = 40 Мпикс, 4.98 MB (худший случай декодера). Один прогон на точку, 2026-10-20.
|
||||
|
||||
| Профиль | N | 201 | p50 / p95 / max, с | RSS до → пик, МиБ (реплика 1 / 2) | cgroup пик, МиБ |
|
||||
| --- | --- | --- | --- | --- | --- |
|
||||
| PNG 9.19 MB | 10 | 10/10 | 2.01 / 2.09 / 2.09 | 99 → 122 / 126 | 153 / 166 |
|
||||
| PNG 9.19 MB | 20 | 20/20 | 3.46 / 3.88 / 3.89 | 99 → 124 / 126 | 215 / 216 |
|
||||
| PNG 9.19 MB | 30 | 30/30 | 4.62 / 4.98 / 7.21 | 99 → 127 / 142 | 255 / 280 |
|
||||
| JPEG 40 Мпикс | 10 | 10/10 | 0.96 / 1.42 / 1.42 | 99 → 334 / 333 | 338 / 338 |
|
||||
| JPEG 40 Мпикс | 20 | 20/20 | 1.77 / 2.59 / 2.74 | 94 → 336 / 336 | 362 / 362 |
|
||||
| JPEG 40 Мпикс | 30 | 30/30 | 2.98 / 6.64 / 6.64 | 99 → 338 / 340 | 391 / 393 |
|
||||
|
||||
**Выводы.** При 15 одновременных PNG на реплику (135 МиБ данных) RSS вырос лишь на 28–43 МиБ. Пик для худшего JPEG (~335 МиБ, буфер коэффициентов libjpeg, ~6 Б/пиксель) не зависит от N: декодирование сериализовано одним потоком, остальные загрузки ждут в очереди, растёт только задержка. Рост cgroup сверх RSS — page cache временных файлов spool, он вытесняемый. Ни одного OOM.
|
||||
|
||||
**Что эксперимент нашёл и что исправлено:**
|
||||
1. Первый прогон: при N = 10 PNG соединения обрывались. В `memory.events` nginx `oom_kill 4`: с `proxy_request_buffering on` nginx складывал тела во временные файлы, и грязный page cache выходил за лимит 64M. Исправлено отключением буферизации на upload-location: тело идёт потоком в API, где память на загрузку ограничена.
|
||||
2. Затем при N = 20 все ответы 503. dmesg: `Killed process (weed) anon-rss:459380kB`, SeaweedFS держал тела в Go-куче. Исправлено `-s3.concurrentUploadLimitMB=128`, `-volume.concurrentUploadLimitMB=128`, `GOMEMLIMIT=384MiB`. Сверх лимита запросы ждут. После исправлений: N = 10/20/30 — 100 % успешно.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| Остановка реплики, принявшей файл | Download через другую, тот же SHA-256 | 10/10 скачиваний с другой реплики, байты совпадают | Без перерыва / нет |
|
||||
| `stop-one.sh` под записью сообщений (×2) | Восстановление ≤ 10 с, без дублей | 0 ошибок, 130 и 129 записей, 2.06 с и 1.62 с | ≤ 2.1 с / нет |
|
||||
| Restart всего стенда с volumes | Данные, файл и прежний токен целы | PASS | ≈ 30 с (SeaweedFS останавливается ~25 с) / нет |
|
||||
| Остановка S3 | Upload/download 503 < 6 с, сообщения и метаданные работают, ready 503 | Так и есть. Компенсация не смогла удалить объект → строка `deleting` → janitor дочистил | Сразу после старта S3 / нет |
|
||||
| Падение API между PUT и COMMIT (внедрено в БД/S3) | janitor удаляет после grace, свежие и `ready` не трогает | `unfinished 2, orphans 1` удалены; свежие пережили первый проход и удалены вторым | grace + интервал / нет |
|
||||
| Обрыв тела загрузки прямо в реплике | Ни строк, ни объектов | 0 строк; API журналирует 400 «Загрузка прервана клиентом» | Мгновенно / нет |
|
||||
| PostgreSQL / Valkey (из lab3) | 503 ограниченно по времени / обход кэша | 4 passed | — |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- **Не выдерживается:** потеря Docker-host. Единственные экземпляры PostgreSQL, SeaweedFS (один volume-сервер без репликации) и nginx — точки отказа. HA хранилищ не заявляется.
|
||||
- PNG проверяется по структуре и CRC без распаковки IDAT: файл с корректными CRC, но испорченным zlib-потоком будет принят. Полное декодирование появится в lab5 у worker (статус `failed`). JPEG декодируется в draft-режиме, это проверяет весь поток данных.
|
||||
- Худший случай памяти на реплику ≈ 100 МиБ база + ~240 МиБ (один progressive JPEG 40 Мпикс) + 1 МиБ × число загрузок. `IMAGE_INSPECT_WORKERS > 1` требует соразмерно поднять лимит контейнера.
|
||||
- Slow-client: после отключения буферизации nginx медленная загрузка держит в API корутину (не поток) до `client_body_timeout` nginx (10 с между чтениями). Отдельного глобального лимита одновременных загрузок на реплику нет: их ограничивают пул SeaweedFS и таймауты.
|
||||
- Grace period 15 мин означает, что объект упавшей загрузки может занимать место до ~16 мин. Это осознанный компромисс в пользу безопасности.
|
||||
- Эксперимент — по одному прогону на точку на ноутбуке. Числа задержек не переносятся на другую машину, переносимы выводы о форме роста памяти.
|
||||
- **Перед сдачей:** повторить `make test-failures` и `make test-persistence` на финальной конфигурации. Последний повтор (12:32–12:33) недействителен: стенд lab4 был остановлен извне, и порт 8080 занял стенд lab3. Подробности в `evidence/*.txt`.
|
||||
|
||||
+296
@@ -0,0 +1,296 @@
|
||||
name: messenger-lab4
|
||||
|
||||
# Один образ приложения для api, migrate, s3-bootstrap и janitor. Собирает его
|
||||
# только api: параллельная сборка одного тега несколькими сервисами конфликтует.
|
||||
x-app: &app
|
||||
image: mtusi-messenger:lab4
|
||||
pull_policy: never
|
||||
env_file:
|
||||
- .env
|
||||
environment: &app-network
|
||||
DB_HOST: postgres
|
||||
DB_PORT: "5432"
|
||||
VALKEY_HOST: valkey
|
||||
VALKEY_PORT: "6379"
|
||||
S3_ENDPOINT: http://s3:9000
|
||||
|
||||
x-api-resources: &api-resources
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 512M
|
||||
reservations:
|
||||
cpus: "0.25"
|
||||
memory: 128M
|
||||
|
||||
x-api: &api
|
||||
<<: *app
|
||||
restart: unless-stopped
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
s3-bootstrap:
|
||||
condition: service_completed_successfully
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
valkey:
|
||||
condition: service_started
|
||||
# Только ограниченные ключи своего bucket; административных у API нет
|
||||
secrets:
|
||||
- s3_access_key_id
|
||||
- s3_secret_access_key
|
||||
networks:
|
||||
- edge
|
||||
- backend
|
||||
- storage
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "src/healthcheck.py"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 2
|
||||
start_period: 20s
|
||||
start_interval: 1s
|
||||
stop_grace_period: 10s
|
||||
|
||||
services:
|
||||
nginx:
|
||||
image: nginx:1.28.0-alpine3.21
|
||||
restart: unless-stopped
|
||||
depends_on:
|
||||
api:
|
||||
condition: service_healthy
|
||||
ports:
|
||||
- "127.0.0.1:${LB_PORT:-8080}:8080"
|
||||
- "127.0.0.1:${LB_EXPIRY_PORT:-8081}:8081"
|
||||
volumes:
|
||||
- ./infra/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
|
||||
- ./infra/nginx/errors.conf:/etc/nginx/errors.conf:ro
|
||||
networks:
|
||||
- edge
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8090/healthz"]
|
||||
interval: 5s
|
||||
timeout: 2s
|
||||
retries: 3
|
||||
stop_grace_period: 10s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 64M
|
||||
|
||||
api:
|
||||
<<: *api
|
||||
build:
|
||||
context: .
|
||||
args:
|
||||
APP_REVISION: ${APP_REVISION:-dev}
|
||||
deploy:
|
||||
<<: *api-resources
|
||||
replicas: ${API_REPLICAS:-2}
|
||||
|
||||
migrate:
|
||||
<<: *app
|
||||
command: ["python", "src/migrate.py"]
|
||||
restart: "no"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
networks:
|
||||
- backend
|
||||
healthcheck:
|
||||
disable: true
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 256M
|
||||
|
||||
postgres:
|
||||
image: postgres:18.2-alpine3.22
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
POSTGRES_USER: ${DB_USER}
|
||||
POSTGRES_PASSWORD: ${DB_PASS}
|
||||
POSTGRES_DB: ${DB_NAME}
|
||||
volumes:
|
||||
- postgres_data:/var/lib/postgresql
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U \"$$POSTGRES_USER\" -d \"$$POSTGRES_DB\""]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 15
|
||||
start_period: 10s
|
||||
networks:
|
||||
- backend
|
||||
stop_grace_period: 30s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.5"
|
||||
memory: 512M
|
||||
|
||||
valkey:
|
||||
image: valkey/valkey:8.1.4-alpine3.22
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
VALKEY_PASS: ${VALKEY_PASS}
|
||||
command:
|
||||
- valkey-server
|
||||
- --requirepass
|
||||
- ${VALKEY_PASS}
|
||||
- --save
|
||||
- ""
|
||||
- --appendonly
|
||||
- "no"
|
||||
- --maxmemory
|
||||
- 64mb
|
||||
- --maxmemory-policy
|
||||
- allkeys-lru
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "valkey-cli --no-auth-warning -a \"$$VALKEY_PASS\" ping | grep -q PONG"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 15
|
||||
networks:
|
||||
- backend
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.25"
|
||||
memory: 96M
|
||||
|
||||
# SeaweedFS всё-в-одном. master, volume, filer и их веб-интерфейсы слушают
|
||||
# только loopback контейнера; в сеть storage открыт лишь S3 API (9000).
|
||||
# Порты наружу не публикуются: bucket доступен только через API.
|
||||
s3:
|
||||
image: chrislusf/seaweedfs:4.48
|
||||
restart: unless-stopped
|
||||
command:
|
||||
- server
|
||||
- -dir=/data
|
||||
- -ip=127.0.0.1
|
||||
- -ip.bind=127.0.0.1
|
||||
- -master.volumeSizeLimitMB=1024
|
||||
- -volume.max=0
|
||||
- -s3
|
||||
- -s3.port=9000
|
||||
- -s3.ip.bind=0.0.0.0
|
||||
- -s3.config=/run/secrets/s3_identities
|
||||
- -s3.port.iceberg=0
|
||||
- -s3.port.lance=0
|
||||
# Тела загрузок SeaweedFS держит в памяти: без лимита 20 одновременных
|
||||
# PUT по 9 MiB вызывали OOM kill weed (evidence/experiment-uploads.json).
|
||||
# Сверх лимита запросы ждут своей очереди.
|
||||
- -s3.concurrentUploadLimitMB=128
|
||||
- -volume.concurrentUploadLimitMB=128
|
||||
environment:
|
||||
# Мягкий предел кучи Go ниже лимита контейнера: GC срабатывает раньше OOM
|
||||
GOMEMLIMIT: 384MiB
|
||||
secrets:
|
||||
- s3_identities
|
||||
volumes:
|
||||
- s3_data:/data
|
||||
networks:
|
||||
- storage
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:9000/healthz"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 30
|
||||
start_period: 10s
|
||||
stop_grace_period: 30s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 512M
|
||||
|
||||
# Идемпотентное создание приватного bucket административными ключами
|
||||
s3-bootstrap:
|
||||
<<: *app
|
||||
command: ["python", "src/s3_bootstrap.py"]
|
||||
restart: "no"
|
||||
depends_on:
|
||||
s3:
|
||||
condition: service_healthy
|
||||
secrets:
|
||||
- s3_admin_access_key_id
|
||||
- s3_admin_secret_access_key
|
||||
networks:
|
||||
- storage
|
||||
healthcheck:
|
||||
disable: true
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 256M
|
||||
|
||||
# Сверка S3/БД: незавершённые загрузки старше grace period и сироты
|
||||
janitor:
|
||||
<<: *app
|
||||
command: ["python", "src/janitor.py"]
|
||||
restart: unless-stopped
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
s3-bootstrap:
|
||||
condition: service_completed_successfully
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
secrets:
|
||||
- s3_access_key_id
|
||||
- s3_secret_access_key
|
||||
networks:
|
||||
- backend
|
||||
- storage
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "src/healthcheck.py", "janitor"]
|
||||
interval: 30s
|
||||
timeout: 5s
|
||||
retries: 3
|
||||
start_period: 30s
|
||||
start_interval: 1s
|
||||
stop_grace_period: 10s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.25"
|
||||
memory: 192M
|
||||
|
||||
api-short-ttl:
|
||||
<<: *api
|
||||
profiles:
|
||||
- expiry
|
||||
environment:
|
||||
<<: *app-network
|
||||
SESSION_TTL_SECONDS: "2"
|
||||
deploy:
|
||||
<<: *api-resources
|
||||
replicas: 1
|
||||
|
||||
networks:
|
||||
edge: {}
|
||||
backend:
|
||||
internal: true
|
||||
# API, janitor и bootstrap ↔ S3; PostgreSQL и Valkey сюда не входят
|
||||
storage:
|
||||
internal: true
|
||||
|
||||
volumes:
|
||||
postgres_data:
|
||||
s3_data:
|
||||
|
||||
# Создаются scripts/init-secrets.sh; в git не попадают
|
||||
secrets:
|
||||
s3_access_key_id:
|
||||
file: ./secrets/s3_access_key_id
|
||||
s3_secret_access_key:
|
||||
file: ./secrets/s3_secret_access_key
|
||||
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_identities:
|
||||
file: ./secrets/s3_identities.json
|
||||
@@ -0,0 +1,254 @@
|
||||
{
|
||||
"environment": {
|
||||
"host": "Darwin arm64",
|
||||
"docker": "29.0.1",
|
||||
"docker_vm_cpus": 10,
|
||||
"docker_vm_memory_gib": 7.7,
|
||||
"api_limits": "cpus 1.0, memory 512M per replica (compose.yaml)",
|
||||
"s3": "chrislusf/seaweedfs:4.48",
|
||||
"settings": {
|
||||
"API_REPLICAS": "2",
|
||||
"MAX_UPLOAD_BYTES": "10485760",
|
||||
"MAX_IMAGE_PIXELS": "40000000",
|
||||
"S3_POOL_MAX_SIZE": "20",
|
||||
"UPLOAD_SPOOL_MEMORY_BYTES": "1048576",
|
||||
"IMAGE_INSPECT_WORKERS": "1"
|
||||
}
|
||||
},
|
||||
"rounds": [
|
||||
{
|
||||
"profile": "png",
|
||||
"file_bytes": 9192108,
|
||||
"concurrency": 10,
|
||||
"replicas_restarted_before": true,
|
||||
"status_counts": {
|
||||
"201": 10
|
||||
},
|
||||
"uploads_by_instance": {
|
||||
"d5c1cf9c56c0": 5,
|
||||
"c194122992eb": 5
|
||||
},
|
||||
"wall_seconds": 2.09,
|
||||
"latency_seconds": {
|
||||
"p50": 2.01,
|
||||
"p95": 2.09,
|
||||
"max": 2.09
|
||||
},
|
||||
"throughput_mib_per_second": 41.9,
|
||||
"download_sha256_matches": true,
|
||||
"replicas": {
|
||||
"messenger-lab4-api-1": {
|
||||
"uploads_served": 5,
|
||||
"rss_before_mib": 99.1,
|
||||
"rss_peak_process_vmhwm_mib": 156.5,
|
||||
"rss_peak_sampled_mib": 121.5,
|
||||
"cgroup_peak_sampled_mib": 152.6,
|
||||
"samples": 20
|
||||
},
|
||||
"messenger-lab4-api-2": {
|
||||
"uploads_served": 5,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 156.5,
|
||||
"rss_peak_sampled_mib": 125.7,
|
||||
"cgroup_peak_sampled_mib": 165.6,
|
||||
"samples": 20
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"profile": "png",
|
||||
"file_bytes": 9192108,
|
||||
"concurrency": 20,
|
||||
"replicas_restarted_before": true,
|
||||
"status_counts": {
|
||||
"201": 20
|
||||
},
|
||||
"uploads_by_instance": {
|
||||
"f6aa4c07652a": 10,
|
||||
"3b495b150936": 10
|
||||
},
|
||||
"wall_seconds": 3.89,
|
||||
"latency_seconds": {
|
||||
"p50": 3.456,
|
||||
"p95": 3.881,
|
||||
"max": 3.888
|
||||
},
|
||||
"throughput_mib_per_second": 45.1,
|
||||
"download_sha256_matches": true,
|
||||
"replicas": {
|
||||
"messenger-lab4-api-1": {
|
||||
"uploads_served": 10,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 156.6,
|
||||
"rss_peak_sampled_mib": 123.6,
|
||||
"cgroup_peak_sampled_mib": 214.6,
|
||||
"samples": 29
|
||||
},
|
||||
"messenger-lab4-api-2": {
|
||||
"uploads_served": 10,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 156.4,
|
||||
"rss_peak_sampled_mib": 126.1,
|
||||
"cgroup_peak_sampled_mib": 216.3,
|
||||
"samples": 29
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"profile": "png",
|
||||
"file_bytes": 9192108,
|
||||
"concurrency": 30,
|
||||
"replicas_restarted_before": true,
|
||||
"status_counts": {
|
||||
"201": 30
|
||||
},
|
||||
"uploads_by_instance": {
|
||||
"5d4554045abd": 15,
|
||||
"51a1d5ba826c": 15
|
||||
},
|
||||
"wall_seconds": 7.21,
|
||||
"latency_seconds": {
|
||||
"p50": 4.62,
|
||||
"p95": 4.979,
|
||||
"max": 7.206
|
||||
},
|
||||
"throughput_mib_per_second": 36.5,
|
||||
"download_sha256_matches": true,
|
||||
"replicas": {
|
||||
"messenger-lab4-api-1": {
|
||||
"uploads_served": 15,
|
||||
"rss_before_mib": 99.1,
|
||||
"rss_peak_process_vmhwm_mib": 156.6,
|
||||
"rss_peak_sampled_mib": 127.1,
|
||||
"cgroup_peak_sampled_mib": 254.8,
|
||||
"samples": 45
|
||||
},
|
||||
"messenger-lab4-api-2": {
|
||||
"uploads_served": 15,
|
||||
"rss_before_mib": 99.1,
|
||||
"rss_peak_process_vmhwm_mib": 156.6,
|
||||
"rss_peak_sampled_mib": 142.0,
|
||||
"cgroup_peak_sampled_mib": 279.8,
|
||||
"samples": 46
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"profile": "jpeg",
|
||||
"file_bytes": 4980814,
|
||||
"concurrency": 10,
|
||||
"replicas_restarted_before": true,
|
||||
"status_counts": {
|
||||
"201": 10
|
||||
},
|
||||
"uploads_by_instance": {
|
||||
"68c5e652faea": 5,
|
||||
"647da7ba9c11": 5
|
||||
},
|
||||
"wall_seconds": 1.42,
|
||||
"latency_seconds": {
|
||||
"p50": 0.958,
|
||||
"p95": 1.416,
|
||||
"max": 1.416
|
||||
},
|
||||
"throughput_mib_per_second": 33.5,
|
||||
"download_sha256_matches": true,
|
||||
"replicas": {
|
||||
"messenger-lab4-api-1": {
|
||||
"uploads_served": 5,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 333.4,
|
||||
"rss_peak_sampled_mib": 334.0,
|
||||
"cgroup_peak_sampled_mib": 338.4,
|
||||
"samples": 17
|
||||
},
|
||||
"messenger-lab4-api-2": {
|
||||
"uploads_served": 5,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 332.6,
|
||||
"rss_peak_sampled_mib": 333.4,
|
||||
"cgroup_peak_sampled_mib": 337.7,
|
||||
"samples": 17
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"profile": "jpeg",
|
||||
"file_bytes": 4980814,
|
||||
"concurrency": 20,
|
||||
"replicas_restarted_before": true,
|
||||
"status_counts": {
|
||||
"201": 20
|
||||
},
|
||||
"uploads_by_instance": {
|
||||
"a54206764ef9": 10,
|
||||
"b85fe6e9cbd7": 10
|
||||
},
|
||||
"wall_seconds": 2.74,
|
||||
"latency_seconds": {
|
||||
"p50": 1.768,
|
||||
"p95": 2.593,
|
||||
"max": 2.738
|
||||
},
|
||||
"throughput_mib_per_second": 34.6,
|
||||
"download_sha256_matches": true,
|
||||
"replicas": {
|
||||
"messenger-lab4-api-1": {
|
||||
"uploads_served": 10,
|
||||
"rss_before_mib": 93.5,
|
||||
"rss_peak_process_vmhwm_mib": 335.0,
|
||||
"rss_peak_sampled_mib": 336.0,
|
||||
"cgroup_peak_sampled_mib": 362.0,
|
||||
"samples": 24
|
||||
},
|
||||
"messenger-lab4-api-2": {
|
||||
"uploads_served": 10,
|
||||
"rss_before_mib": 93.5,
|
||||
"rss_peak_process_vmhwm_mib": 337.4,
|
||||
"rss_peak_sampled_mib": 336.0,
|
||||
"cgroup_peak_sampled_mib": 362.4,
|
||||
"samples": 24
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"profile": "jpeg",
|
||||
"file_bytes": 4980814,
|
||||
"concurrency": 30,
|
||||
"replicas_restarted_before": true,
|
||||
"status_counts": {
|
||||
"201": 30
|
||||
},
|
||||
"uploads_by_instance": {
|
||||
"da06b29a8834": 15,
|
||||
"0ff93f8a6fd8": 15
|
||||
},
|
||||
"wall_seconds": 6.64,
|
||||
"latency_seconds": {
|
||||
"p50": 2.981,
|
||||
"p95": 6.635,
|
||||
"max": 6.635
|
||||
},
|
||||
"throughput_mib_per_second": 21.5,
|
||||
"download_sha256_matches": true,
|
||||
"replicas": {
|
||||
"messenger-lab4-api-1": {
|
||||
"uploads_served": 15,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 337.4,
|
||||
"rss_peak_sampled_mib": 337.9,
|
||||
"cgroup_peak_sampled_mib": 390.6,
|
||||
"samples": 43
|
||||
},
|
||||
"messenger-lab4-api-2": {
|
||||
"uploads_served": 15,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 339.1,
|
||||
"rss_peak_sampled_mib": 339.7,
|
||||
"cgroup_peak_sampled_mib": 393.1,
|
||||
"samples": 43
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
## instances before
|
||||
CONTAINER STATE INSTANCE PID REVISION
|
||||
messenger-lab4-api-1 running/healthy 0fd6b920cefc 2735 dev
|
||||
messenger-lab4-api-2 running/healthy 5a67f0c47be1 2687 dev
|
||||
## make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
{"observed_instances_before": 2, "successful_writes": 130, "failed_attempts": 0, "first_recovery_seconds": 2.058}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
## instances after (stopped replica stays stopped)
|
||||
CONTAINER STATE INSTANCE PID REVISION
|
||||
messenger-lab4-api-1 exited/unhealthy - 0 dev
|
||||
messenger-lab4-api-2 running/healthy 5a67f0c47be1 2687 dev
|
||||
|
||||
## second run after scripts/restore.sh
|
||||
CONTAINER STATE INSTANCE PID REVISION
|
||||
messenger-lab4-api-1 running/healthy 04c6c919ec65 5688 dev
|
||||
messenger-lab4-api-2 running/healthy 5a67f0c47be1 2687 dev
|
||||
{"observed_instances_before": 2, "successful_writes": 129, "failed_attempts": 0, "first_recovery_seconds": 1.618}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
CONTAINER STATE INSTANCE PID REVISION
|
||||
messenger-lab4-api-1 exited/unhealthy - 0 dev
|
||||
messenger-lab4-api-2 running/healthy 5a67f0c47be1 2687 dev
|
||||
@@ -0,0 +1,19 @@
|
||||
# make test-failures (PostgreSQL, Valkey, S3, остановка реплики, принявшей файл)
|
||||
#
|
||||
# 2026-10-20 ~12:05 MSK — 6 passed (до включения S3 в readiness, отключения
|
||||
# буферизации nginx и лимитов SeaweedFS).
|
||||
student-tests/test_dependency_failures.py::test_valkey_down_cache_is_bypassed PASSED
|
||||
student-tests/test_dependency_failures.py::test_logout_during_valkey_outage_is_not_resurrected PASSED
|
||||
student-tests/test_dependency_failures.py::test_postgres_down_returns_bounded_503_and_no_anonymous_access PASSED
|
||||
student-tests/test_dependency_failures.py::test_session_survives_postgres_restart PASSED
|
||||
student-tests/test_storage_failures.py::test_s3_outage_is_isolated_and_leaves_no_garbage PASSED
|
||||
student-tests/test_attachment_failover.py::test_download_survives_stop_of_uploading_replica
|
||||
UPLOADED BY 5a67f0c47be1, DOWNLOADED FROM ['da68a0e82155']
|
||||
PASSED
|
||||
========================= 6 passed in 70.80s (0:01:10) =========================
|
||||
|
||||
# 2026-10-20 12:32 MSK — повторный прогон НЕДЕЙСТВИТЕЛЕН (5 passed, 1 failed):
|
||||
# во время прогона стенд lab4 был остановлен извне и порт 8080 занял стенд lab3.
|
||||
# test_attachment_failover отдельно на lab4 после этого: 1 passed
|
||||
# (UPLOADED BY 67c813dd874b, DOWNLOADED FROM ['82dc3cadef5c']).
|
||||
# Повторить make test-failures на финальной конфигурации перед сдачей.
|
||||
@@ -0,0 +1,27 @@
|
||||
# make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
#
|
||||
# 2026-10-20 ~12:17 MSK — PASS (readiness с проверкой S3, до отключения
|
||||
# буферизации nginx и лимитов SeaweedFS; эти изменения не касаются сохранности).
|
||||
## containers before
|
||||
api messenger-lab4-api-1 Up 10 seconds (healthy)
|
||||
api messenger-lab4-api-2 Up 10 seconds (healthy)
|
||||
janitor messenger-lab4-janitor-1 Up 10 seconds (healthy)
|
||||
nginx messenger-lab4-nginx-1 Up About a minute (healthy)
|
||||
postgres messenger-lab4-postgres-1 Up About a minute (healthy)
|
||||
s3 messenger-lab4-s3-1 Up About a minute (healthy)
|
||||
valkey messenger-lab4-valkey-1 Up About a minute (healthy)
|
||||
## make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
## containers after (uptime сброшен у всех: реально перезапущены PostgreSQL, Valkey, S3, API, janitor, nginx)
|
||||
api messenger-lab4-api-1 Up 15 seconds (healthy)
|
||||
api messenger-lab4-api-2 Up 15 seconds (health: starting)
|
||||
janitor messenger-lab4-janitor-1 Up 16 seconds (healthy)
|
||||
nginx messenger-lab4-nginx-1 Up 15 seconds (healthy)
|
||||
postgres messenger-lab4-postgres-1 Up 42 seconds (healthy)
|
||||
s3 messenger-lab4-s3-1 Up 17 seconds (health: starting)
|
||||
valkey messenger-lab4-valkey-1 Up 42 seconds (healthy)
|
||||
|
||||
# 2026-10-20 12:33 MSK — повторный прогон НЕДЕЙСТВИТЕЛЕН: во время прогона стенд
|
||||
# lab4 был остановлен извне, на 127.0.0.1:8080 работал стенд lab3 (его ответы
|
||||
# без attachment_ids). Повторить на финальной конфигурации перед сдачей.
|
||||
@@ -0,0 +1,9 @@
|
||||
## make check
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
## make test
|
||||
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
|
||||
## make student-test (unit + black-box)
|
||||
======================= 187 passed, 16 skipped in 23.48s =======================
|
||||
## make test-storage
|
||||
JANITOR REPORT: {"dry_run": false, "unfinished_claimed": 2, "unfinished_objects_deleted": 2, "unfinished_rows_deleted": 2, "objects_scanned": 381, "orphan_objects_found": 1, "orphan_objects_deleted": 1}
|
||||
======================== 8 passed in 114.70s (0:01:54) =========================
|
||||
@@ -0,0 +1,15 @@
|
||||
# Ошибки, созданные самим балансировщиком, — в формате ошибок контракта.
|
||||
# Ответы реплик (включая их 503) проходят без изменений: proxy_intercept_errors off.
|
||||
# X-Instance-Id здесь нет: ответ создан LB, а не API-репликой.
|
||||
|
||||
location @unavailable {
|
||||
default_type application/json;
|
||||
add_header X-Request-Id $request_id always;
|
||||
return 503 '{"error":{"code":"unavailable","message":"Нет доступной API-реплики","request_id":"$request_id"}}';
|
||||
}
|
||||
|
||||
location @too_large {
|
||||
default_type application/json;
|
||||
add_header X-Request-Id $request_id always;
|
||||
return 413 '{"error":{"code":"payload_too_large","message":"Тело запроса слишком большое","request_id":"$request_id"}}';
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
worker_processes 1;
|
||||
pid /tmp/nginx.pid;
|
||||
error_log /dev/stderr warn;
|
||||
|
||||
events {
|
||||
worker_connections 1024;
|
||||
}
|
||||
|
||||
http {
|
||||
resolver 127.0.0.11 valid=2s ipv6=off;
|
||||
resolver_timeout 1s;
|
||||
|
||||
log_format upstream_json escape=json
|
||||
'{"time":"$time_iso8601","request_id":"$request_id",'
|
||||
'"method":"$request_method","uri":"$uri","status":$status,'
|
||||
'"request_time":$request_time,"upstream_addr":"$upstream_addr",'
|
||||
'"upstream_status":"$upstream_status",'
|
||||
'"upstream_response_time":"$upstream_response_time",'
|
||||
'"instance":"$upstream_http_x_instance_id"}';
|
||||
access_log /dev/stdout upstream_json;
|
||||
|
||||
server_tokens off;
|
||||
client_max_body_size 1m;
|
||||
client_body_buffer_size 64k;
|
||||
client_header_timeout 10s;
|
||||
client_body_timeout 10s;
|
||||
send_timeout 10s;
|
||||
keepalive_timeout 65s;
|
||||
|
||||
upstream api {
|
||||
zone api 64k;
|
||||
server api:8080 resolve max_fails=1 fail_timeout=5s;
|
||||
keepalive 32;
|
||||
# Меньше APP_KEEPALIVE_TIMEOUT_SEC (75 с): idle-соединение первым
|
||||
# закрывает nginx, а не реплика, — нет гонки «запрос в закрытое соединение»
|
||||
keepalive_timeout 60s;
|
||||
}
|
||||
|
||||
proxy_http_version 1.1;
|
||||
proxy_set_header Connection "";
|
||||
proxy_set_header Host $host;
|
||||
# Один ID на LB и реплику: API принимает $request_id и возвращает его
|
||||
proxy_set_header X-Request-Id $request_id;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
proxy_set_header X-Forwarded-Proto $scheme;
|
||||
|
||||
# connect внутри bridge-сети завершает ядро за доли мс даже у занятой реплики.
|
||||
# Самый долгий запрос API: ожидание пула 3 с + statement_timeout 5 с
|
||||
proxy_connect_timeout 500ms;
|
||||
proxy_send_timeout 10s;
|
||||
proxy_read_timeout 10s;
|
||||
|
||||
# Повтор на другой реплике только при ошибке соединения/таймауте.
|
||||
# POST, уже отправленный реплике, nginx не повторяет (non_idempotent выключен):
|
||||
# повтор сообщения делает клиент с тем же Idempotency-Key.
|
||||
# 503 приложения (общая зависимость недоступна) не повторяется и не исключает
|
||||
# реплику: другая реплика зависит от той же БД.
|
||||
proxy_next_upstream error timeout;
|
||||
proxy_next_upstream_tries 3;
|
||||
proxy_next_upstream_timeout 5s;
|
||||
|
||||
server {
|
||||
listen 8080;
|
||||
|
||||
location / {
|
||||
proxy_pass http://api;
|
||||
}
|
||||
|
||||
# Загрузка вложения. Лимит LB чуть больше лимита API (10 MiB): тело
|
||||
# 10 MiB + 1 отклоняет сама реплика ответом 413 по контракту, а LB
|
||||
# отсекает только заведомо огромные тела.
|
||||
# Тело НЕ буферизуется в nginx, а идёт потоком в API (там память
|
||||
# на загрузку ограничена spool 1 MiB). С буферизацией 10 одновременных
|
||||
# тел по 9 MiB во временных файлах nginx давали грязный page cache
|
||||
# сверх лимита контейнера 64M и OOM kill воркеров (эксперимент
|
||||
# evidence/experiment-uploads.json). Медленный клиент занимает в API
|
||||
# только корутину; client_body_timeout обрывает зависшую передачу.
|
||||
# read timeout больше ATTACHMENT_STORE_TIMEOUT_SEC (30 с) + проверки.
|
||||
location ~ ^/api/v1/chats/[^/]+/attachments$ {
|
||||
client_max_body_size 11m;
|
||||
proxy_request_buffering off;
|
||||
proxy_read_timeout 45s;
|
||||
proxy_pass http://api;
|
||||
}
|
||||
|
||||
error_page 502 503 504 = @unavailable;
|
||||
error_page 413 = @too_large;
|
||||
|
||||
include /etc/nginx/errors.conf;
|
||||
}
|
||||
|
||||
server {
|
||||
listen 8081;
|
||||
|
||||
# Реплика api-short-ttl только для make test-expiry (профиль expiry):
|
||||
# адрес резолвится на каждый запрос, без профиля — 503 от LB
|
||||
location / {
|
||||
set $api_short_ttl http://api-short-ttl:8080;
|
||||
proxy_pass $api_short_ttl;
|
||||
}
|
||||
|
||||
error_page 502 503 504 = @unavailable;
|
||||
error_page 413 = @too_large;
|
||||
|
||||
include /etc/nginx/errors.conf;
|
||||
}
|
||||
|
||||
# Liveness самого балансировщика для healthcheck контейнера; наружу не публикуется
|
||||
server {
|
||||
listen 127.0.0.1:8090;
|
||||
access_log off;
|
||||
|
||||
location = /healthz {
|
||||
default_type text/plain;
|
||||
return 200 "ok\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY DEFAULT uuidv7(),
|
||||
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)
|
||||
);
|
||||
|
||||
-- Источник истины для сессий; токен хранится только как SHA-256
|
||||
CREATE TABLE sessions (
|
||||
token_hash bytea PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
|
||||
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_order CHECK (expires_at > created_at)
|
||||
);
|
||||
|
||||
CREATE INDEX sessions_user_id_idx ON sessions (user_id);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY DEFAULT uuidv7(),
|
||||
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)
|
||||
);
|
||||
|
||||
-- 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)
|
||||
);
|
||||
|
||||
-- Список чатов пользователя: WHERE user_id = $1
|
||||
CREATE INDEX chat_members_user_id_chat_id_idx ON chat_members (user_id, chat_id);
|
||||
|
||||
-- created_at назначает приложение под блокировкой чата (строго возрастает в чате)
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY DEFAULT uuidv7(),
|
||||
chat_id uuid NOT NULL,
|
||||
sender_id uuid NOT NULL,
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL,
|
||||
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000),
|
||||
-- отправитель обязан быть участником этого чата
|
||||
CONSTRAINT messages_sender_member_fkey FOREIGN KEY (chat_id, sender_id)
|
||||
REFERENCES chat_members (chat_id, user_id) ON DELETE CASCADE
|
||||
);
|
||||
|
||||
-- Keyset-пагинация истории: WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
-- ORDER BY created_at, id LIMIT $4 — Index Scan без сортировки и полного прохода
|
||||
CREATE INDEX messages_chat_id_created_at_id_idx ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1,18 @@
|
||||
-- Idempotency-Key отправки сообщения (lab3). Область по контракту:
|
||||
-- пользователь + метод + путь + ключ. Метод и путь фиксированы
|
||||
-- (POST /api/v1/chats/{chat_id}/messages), поэтому ключ — (sender_id, chat_id, key).
|
||||
-- Только добавление таблицы (expand): предыдущая версия API работает на новой схеме.
|
||||
CREATE TABLE message_idempotency_keys (
|
||||
sender_id uuid NOT NULL,
|
||||
chat_id uuid NOT NULL,
|
||||
idempotency_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(),
|
||||
expires_at timestamptz NOT NULL,
|
||||
PRIMARY KEY (sender_id, chat_id, idempotency_key),
|
||||
CONSTRAINT message_idempotency_keys_key_format
|
||||
CHECK (idempotency_key ~ '^[A-Za-z0-9._:-]{1,128}$'),
|
||||
CONSTRAINT message_idempotency_keys_hash_len CHECK (octet_length(request_hash) = 32),
|
||||
CONSTRAINT message_idempotency_keys_expiry_order CHECK (expires_at > created_at)
|
||||
);
|
||||
@@ -0,0 +1,69 @@
|
||||
-- Вложения (lab4): метаданные в PostgreSQL, байты — в приватном bucket S3.
|
||||
-- Только расширение схемы (expand): API lab3 продолжает работать на новой схеме.
|
||||
|
||||
-- Строка создаётся ДО записи объекта в S3 (status = pending) и удаляется только
|
||||
-- ПОСЛЕ удаления объекта (через deleting). Поэтому у каждого объекта S3 есть
|
||||
-- строка, и janitor находит незавершённые загрузки по БД, а не обходом bucket.
|
||||
CREATE TABLE attachments (
|
||||
id uuid PRIMARY KEY DEFAULT uuidv7(),
|
||||
chat_id uuid NOT NULL,
|
||||
owner_id uuid NOT NULL,
|
||||
filename text NOT NULL,
|
||||
content_type text NOT NULL,
|
||||
size_bytes integer NOT NULL,
|
||||
sha256 bytea NOT NULL,
|
||||
-- назначает сервер (originals/<random>); filename в ключ не входит
|
||||
object_key text NOT NULL,
|
||||
status text NOT NULL DEFAULT 'pending',
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
updated_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
CONSTRAINT attachments_object_key_key UNIQUE (object_key),
|
||||
-- цель составного FK из message_attachments: вложение того же чата
|
||||
CONSTRAINT attachments_id_chat_id_key UNIQUE (id, chat_id),
|
||||
-- загружать может только участник чата; без CASCADE: молча удалённая
|
||||
-- строка оставила бы объект S3 неучтённым
|
||||
CONSTRAINT attachments_owner_member_fkey FOREIGN KEY (chat_id, owner_id)
|
||||
REFERENCES chat_members (chat_id, user_id),
|
||||
CONSTRAINT attachments_status_check
|
||||
CHECK (status IN ('pending', 'ready', 'deleting')),
|
||||
CONSTRAINT attachments_content_type_check
|
||||
CHECK (content_type IN ('image/png', 'image/jpeg')),
|
||||
CONSTRAINT attachments_size_bytes_range CHECK (size_bytes BETWEEN 1 AND 10485760),
|
||||
CONSTRAINT attachments_sha256_len CHECK (octet_length(sha256) = 32),
|
||||
CONSTRAINT attachments_filename_len CHECK (char_length(filename) BETWEEN 1 AND 255)
|
||||
);
|
||||
|
||||
-- janitor: WHERE status <> 'ready' AND created_at < now() - grace;
|
||||
-- готовых строк подавляющее большинство, в индекс они не попадают
|
||||
CREATE INDEX attachments_unfinished_created_at_idx
|
||||
ON attachments (created_at)
|
||||
WHERE status <> 'ready';
|
||||
|
||||
-- Пустой текст допустим, если у сообщения есть вложения (проверяет API:
|
||||
-- условие охватывает две таблицы). Ограничение только ослабляется.
|
||||
ALTER TABLE messages DROP CONSTRAINT messages_text_len;
|
||||
ALTER TABLE messages
|
||||
ADD CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 0 AND 4000);
|
||||
|
||||
-- цель составного FK из message_attachments: сообщение того же чата
|
||||
ALTER TABLE messages ADD CONSTRAINT messages_id_chat_id_key UNIQUE (id, chat_id);
|
||||
|
||||
-- position сохраняет порядок attachment_ids из запроса
|
||||
CREATE TABLE message_attachments (
|
||||
message_id uuid NOT NULL,
|
||||
chat_id uuid NOT NULL,
|
||||
attachment_id uuid NOT NULL,
|
||||
position smallint NOT NULL,
|
||||
PRIMARY KEY (message_id, position),
|
||||
CONSTRAINT message_attachments_attachment_key UNIQUE (message_id, attachment_id),
|
||||
CONSTRAINT message_attachments_message_fkey FOREIGN KEY (message_id, chat_id)
|
||||
REFERENCES messages (id, chat_id) ON DELETE CASCADE,
|
||||
-- вложение принадлежит чату сообщения; используемое вложение не удалить
|
||||
CONSTRAINT message_attachments_attachment_fkey FOREIGN KEY (attachment_id, chat_id)
|
||||
REFERENCES attachments (id, chat_id),
|
||||
CONSTRAINT message_attachments_position_range CHECK (position BETWEEN 0 AND 9)
|
||||
);
|
||||
|
||||
-- Проверка FK при удалении вложения: без индекса — полный проход таблицы
|
||||
CREATE INDEX message_attachments_attachment_id_idx
|
||||
ON message_attachments (attachment_id);
|
||||
Generated
+2008
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,31 @@
|
||||
[tool.poetry]
|
||||
name = "max2"
|
||||
version = "1.2.0"
|
||||
description = "Мессенджер на PostgreSQL и Valkey, лабораторная 3"
|
||||
authors = ["Саватеев Артём"]
|
||||
package-mode = false
|
||||
|
||||
[tool.poetry.dependencies]
|
||||
python = ">=3.12,<3.13"
|
||||
fastapi = "0.142.2"
|
||||
uvicorn = "0.54.0"
|
||||
pydantic = "2.13.5"
|
||||
envparse = "0.2.0"
|
||||
loguru = "0.7.3"
|
||||
asyncpg = "0.31.0"
|
||||
redis = "6.4.0"
|
||||
argon2-cffi = "25.1.0"
|
||||
aiobotocore = "3.9.1"
|
||||
pillow = "12.3.0"
|
||||
|
||||
[tool.poetry.group.dev.dependencies]
|
||||
pytest = "9.1.1"
|
||||
httpx = "0.28.1"
|
||||
|
||||
[build-system]
|
||||
requires = ["poetry-core>=2.0.0,<3.0.0"]
|
||||
build-backend = "poetry.core.masonry.api"
|
||||
|
||||
[tool.pytest.ini_options]
|
||||
testpaths = ["student-tests"]
|
||||
addopts = "-v"
|
||||
Executable
+58
@@ -0,0 +1,58 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Миграции с нуля и повторно, отказ API на непримененной схеме: отдельный
|
||||
# compose-проект с собственным пустым volume. Рабочий стенд и его данные
|
||||
# не затрагиваются; временный volume этого проекта удаляется в конце.
|
||||
cd "$(dirname "$0")/.."
|
||||
PROJECT=messenger-lab4-migrations-check
|
||||
# Публикуется только порт LB: свои порты, чтобы не конфликтовать с основным стендом
|
||||
export LB_PORT="${MIGRATIONS_CHECK_LB_PORT:-58080}"
|
||||
export LB_EXPIRY_PORT="${MIGRATIONS_CHECK_LB_EXPIRY_PORT:-58081}"
|
||||
COMPOSE="docker compose --env-file ${ENV_FILE:-.env} -p $PROJECT"
|
||||
trap '$COMPOSE down -v --remove-orphans >/dev/null 2>&1' EXIT
|
||||
|
||||
$COMPOSE up -d --wait postgres >/dev/null 2>&1
|
||||
# Тот же образ и сеть, что у сервиса migrate; apply_migrations трижды подряд
|
||||
$COMPOSE run --rm --no-deps -T migrate python - <<'EOF'
|
||||
import asyncio
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, "src")
|
||||
|
||||
from infrastructure.dependencies.database import database_pool_manager as db
|
||||
|
||||
|
||||
async def main() -> None:
|
||||
await db.create_pool(30)
|
||||
async with db.acquire() as conn:
|
||||
tables = await conn.fetchval(
|
||||
"SELECT count(*) FROM pg_tables WHERE schemaname = 'public';"
|
||||
)
|
||||
print(f"пустой volume: таблиц в public = {tables}")
|
||||
# Так стартует API-реплика: без migrate она отказывается работать
|
||||
try:
|
||||
await db.check_migrations()
|
||||
except RuntimeError as error:
|
||||
print(f"API до migrate: {error}")
|
||||
else:
|
||||
raise SystemExit("FAIL: API стартовал бы на пустой схеме")
|
||||
for attempt in (1, 2, 3):
|
||||
await db.apply_migrations()
|
||||
async with db.acquire() as conn:
|
||||
versions = await conn.fetch(
|
||||
"SELECT version, name FROM schema_migrations ORDER BY version;"
|
||||
)
|
||||
tables = await conn.fetchval(
|
||||
"SELECT count(*) FROM pg_tables WHERE schemaname = 'public';"
|
||||
)
|
||||
print(
|
||||
f"запуск {attempt}: schema_migrations = "
|
||||
f"{[(r['version'], r['name']) for r in versions]}, таблиц = {tables}"
|
||||
)
|
||||
await db.check_migrations()
|
||||
print("API после migrate: схема совместима")
|
||||
await db.close()
|
||||
|
||||
|
||||
asyncio.run(main())
|
||||
EOF
|
||||
Executable
+89
@@ -0,0 +1,89 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Совместимость текущей схемы с предыдущей версией API — условие rolling update:
|
||||
# миграции применяются до замены реплик, и старые реплики продолжают работать.
|
||||
# Образ собирается из коммита PREVIOUS_REVISION (по умолчанию lab2-код aa971fb),
|
||||
# запускается одним процессом в сети backend рабочего стенда (наружу порт
|
||||
# не публикуется) и выполняет вход, создание чата, запись и чтение сообщения.
|
||||
# Создаются только синтетические данные; volumes не затрагиваются.
|
||||
cd "$(dirname "$0")/.."
|
||||
ENV_FILE="${ENV_FILE:-.env}"
|
||||
REVISION="${PREVIOUS_REVISION:-aa971fb}"
|
||||
IMAGE="mtusi-messenger:compat-$REVISION"
|
||||
NETWORK=messenger-lab3_backend
|
||||
|
||||
git archive "$REVISION" | docker build --quiet --tag "$IMAGE" - >/dev/null
|
||||
echo "previous version image: $IMAGE ($(git log -1 --format='%h %s' "$REVISION"))"
|
||||
echo "schema on stand: $(docker compose --env-file "$ENV_FILE" exec -T postgres sh -c \
|
||||
'psql -X -q -tA -U "$POSTGRES_USER" -d "$POSTGRES_DB" -c "SELECT string_agg(name, \$\$, \$\$ ORDER BY version) FROM schema_migrations;"')"
|
||||
|
||||
docker run --rm -i --network "$NETWORK" --env-file "$ENV_FILE" \
|
||||
-e DB_HOST=postgres -e DB_PORT=5432 -e VALKEY_HOST=valkey -e VALKEY_PORT=6379 \
|
||||
"$IMAGE" sh -c 'python src/gateway.py >/tmp/api.log 2>&1 & exec python -' <<'EOF'
|
||||
import base64
|
||||
import json
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
BASE = "http://127.0.0.1:8080"
|
||||
|
||||
|
||||
def call(method, path, body=None, headers=None):
|
||||
data = None if body is None else json.dumps(body).encode()
|
||||
request = urllib.request.Request(BASE + path, data=data, method=method)
|
||||
request.add_header("Content-Type", "application/json")
|
||||
for name, value in (headers or {}).items():
|
||||
request.add_header(name, value)
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=5) as response:
|
||||
return response.status, json.loads(response.read() or b"null")
|
||||
except urllib.error.HTTPError as error:
|
||||
return error.code, None
|
||||
|
||||
|
||||
for _ in range(60):
|
||||
try:
|
||||
if call("GET", "/health/ready")[0] == 200:
|
||||
break
|
||||
except OSError:
|
||||
pass
|
||||
time.sleep(0.5)
|
||||
else:
|
||||
print(open("/tmp/api.log").read()[-2000:])
|
||||
raise SystemExit("FAIL: previous version did not become ready on current schema")
|
||||
|
||||
username = "compat_" + uuid.uuid4().hex[:12]
|
||||
password = "Compat-" + uuid.uuid4().hex
|
||||
status_user, user = call(
|
||||
"POST", "/api/v1/users",
|
||||
{"username": username, "display_name": "Compat", "password": password},
|
||||
)
|
||||
credentials = base64.b64encode(f"{username}:{password}".encode()).decode()
|
||||
status_login, session = call(
|
||||
"POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + credentials}
|
||||
)
|
||||
bearer = {"Authorization": "Bearer " + session["token"]}
|
||||
status_chat, chat = call(
|
||||
"POST", "/api/v1/chats", {"title": "compat", "member_ids": [user["id"]]}, bearer
|
||||
)
|
||||
path = f"/api/v1/chats/{chat['id']}/messages"
|
||||
status_send, message = call("POST", path, {"text": "старая версия пишет"}, bearer)
|
||||
status_read, page = call("GET", path, headers=bearer)
|
||||
result = {
|
||||
"ready": True,
|
||||
"register": status_user,
|
||||
"login": status_login,
|
||||
"create_chat": status_chat,
|
||||
"send_message_without_key": status_send,
|
||||
"read_history": status_read,
|
||||
"history_matches": page["items"] == [message],
|
||||
}
|
||||
print(json.dumps(result, ensure_ascii=False))
|
||||
log = open("/tmp/api.log").read()
|
||||
print("startup log:", [line.split(" - ", 1)[-1] for line in log.splitlines() if "миграц" in line.lower() or "Схема" in line])
|
||||
if any(code >= 400 for code in result.values() if isinstance(code, int)) or not result["history_matches"]:
|
||||
raise SystemExit("FAIL: previous version is not compatible with current schema")
|
||||
print("PASS: previous API version works on the current schema (expand-only migration)")
|
||||
EOF
|
||||
@@ -0,0 +1,480 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Нагрузка через LB во время отказа/замены API-реплик; метрики и проверка данных.
|
||||
|
||||
failover — для каждой API-реплики по очереди: нагрузка → остановка этой реплики
|
||||
(docker stop = SIGTERM, затем docker kill = SIGKILL) → восстановление
|
||||
(scripts/restore.sh) → нагрузка после восстановления.
|
||||
rolling — нагрузка во время scripts/rolling-update.sh (поочерёдная замена реплик).
|
||||
|
||||
Клиент ведёт себя как настоящий: неподтверждённый POST повторяет с тем же
|
||||
Idempotency-Key и телом. После прогона вся история читается заново: каждое
|
||||
подтверждённое сообщение на месте и не изменено, дублей нет.
|
||||
Python 3.9+, стандартная библиотека; tokens не печатаются и не сохраняются.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
from urllib.parse import quote
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "tests"))
|
||||
|
||||
from client import Client # noqa: E402
|
||||
|
||||
REQUEST_TIMEOUT_SEC = 5
|
||||
RETRY_PAUSE_SEC = 0.05
|
||||
STATS_FORMAT = "{{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"
|
||||
|
||||
|
||||
@dataclass
|
||||
class Attempt:
|
||||
"""Одна HTTP-попытка клиента; время — секунды от начала прогона"""
|
||||
|
||||
op: str
|
||||
started: float
|
||||
finished: float
|
||||
status: int | None
|
||||
error: str | None
|
||||
instance: str | None
|
||||
retry: bool
|
||||
|
||||
@property
|
||||
def ok(self) -> bool:
|
||||
return self.status in (200, 201)
|
||||
|
||||
|
||||
class Recorder:
|
||||
def __init__(self) -> None:
|
||||
self.started = time.monotonic()
|
||||
self.lock = threading.Lock()
|
||||
self.attempts: list[Attempt] = []
|
||||
self.confirmed: list[dict] = []
|
||||
self.events: dict[str, float] = {}
|
||||
|
||||
def now(self) -> float:
|
||||
return time.monotonic() - self.started
|
||||
|
||||
def mark(self, name: str) -> None:
|
||||
self.events[name] = round(self.now(), 3)
|
||||
|
||||
def add(self, attempt: Attempt, message: dict | None = None) -> None:
|
||||
with self.lock:
|
||||
self.attempts.append(attempt)
|
||||
if message is not None:
|
||||
self.confirmed.append(message)
|
||||
|
||||
|
||||
def request(
|
||||
base: str, method: str, path: str, token: str, body: dict | None, key: str | None
|
||||
) -> tuple[int | None, str | None, str | None, dict | None]:
|
||||
headers = {"Authorization": "Bearer " + token, "Accept": "application/json"}
|
||||
data = None
|
||||
if body is not None:
|
||||
data = json.dumps(body, ensure_ascii=False).encode()
|
||||
headers["Content-Type"] = "application/json"
|
||||
if key is not None:
|
||||
headers["Idempotency-Key"] = key
|
||||
req = urllib.request.Request(base + path, data=data, headers=headers, method=method)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=REQUEST_TIMEOUT_SEC) as response:
|
||||
payload = json.loads(response.read())
|
||||
return response.status, None, response.headers.get("X-Instance-Id"), payload
|
||||
except urllib.error.HTTPError as error:
|
||||
error.read()
|
||||
return error.code, None, error.headers.get("X-Instance-Id"), None
|
||||
except OSError as error:
|
||||
return None, type(error).__name__, None, None
|
||||
|
||||
|
||||
def worker(
|
||||
base: str,
|
||||
token: str,
|
||||
chat_id: str,
|
||||
worker_id: int,
|
||||
recorder: Recorder,
|
||||
stop: threading.Event,
|
||||
) -> None:
|
||||
"""Запись с повтором по тому же ключу до подтверждения, затем чтение"""
|
||||
path = f"/api/v1/chats/{chat_id}/messages"
|
||||
index = 0
|
||||
while not stop.is_set():
|
||||
key = uuid.uuid4().hex
|
||||
body = {"text": f"exp-{worker_id}-{index}-{key[:8]}"}
|
||||
retry = False
|
||||
while not stop.is_set():
|
||||
started = recorder.now()
|
||||
status, error, instance, payload = request(
|
||||
base, "POST", path, token, body, key
|
||||
)
|
||||
attempt = Attempt(
|
||||
"write", started, recorder.now(), status, error, instance, retry
|
||||
)
|
||||
recorder.add(attempt, payload if status == 201 else None)
|
||||
if status == 201:
|
||||
break
|
||||
retry = True
|
||||
time.sleep(RETRY_PAUSE_SEC)
|
||||
started = recorder.now()
|
||||
status, error, instance, _ = request(
|
||||
base, "GET", path + "?limit=1", token, None, None
|
||||
)
|
||||
recorder.add(
|
||||
Attempt("read", started, recorder.now(), status, error, instance, False)
|
||||
)
|
||||
index += 1
|
||||
|
||||
|
||||
def percentile(values: list[float], p: float) -> float | None:
|
||||
if not values:
|
||||
return None
|
||||
ordered = sorted(values)
|
||||
return round(1000 * ordered[max(0, math.ceil(p * len(ordered)) - 1)], 1)
|
||||
|
||||
|
||||
def phase_stats(attempts: list[Attempt], start: float, end: float) -> dict:
|
||||
inside = [a for a in attempts if start <= a.finished < end]
|
||||
duration = max(end - start, 1e-9)
|
||||
result: dict = {"seconds": round(duration, 3)}
|
||||
for op in ("write", "read"):
|
||||
ops = [a for a in inside if a.op == op]
|
||||
ok = [a for a in ops if a.ok]
|
||||
result[op] = {
|
||||
"ok": len(ok),
|
||||
"errors": len(ops) - len(ok),
|
||||
"ok_rps": round(len(ok) / duration, 1),
|
||||
"latency_ms": {
|
||||
"p50": percentile([a.finished - a.started for a in ok], 0.50),
|
||||
"p95": percentile([a.finished - a.started for a in ok], 0.95),
|
||||
"p99": percentile([a.finished - a.started for a in ok], 0.99),
|
||||
},
|
||||
}
|
||||
return result
|
||||
|
||||
|
||||
def recovery_stats(attempts: list[Attempt], action_start: float, end: float) -> dict:
|
||||
"""
|
||||
Время восстановления записи: от первой ошибки после воздействия до первой
|
||||
успешной записи после последней ошибки; без ошибок — 0. Отдельно —
|
||||
наибольший разрыв между подтверждениями записи (задержка без ошибок).
|
||||
"""
|
||||
window = sorted(
|
||||
(a for a in attempts if a.op == "write" and a.finished >= action_start - 1),
|
||||
key=lambda a: a.finished,
|
||||
)
|
||||
errors = [a for a in window if not a.ok and a.finished >= action_start]
|
||||
kinds: dict[str, int] = {}
|
||||
for a in errors:
|
||||
kind = a.error or f"HTTP {a.status}"
|
||||
kinds[kind] = kinds.get(kind, 0) + 1
|
||||
if errors:
|
||||
last_error = errors[-1].finished
|
||||
first_ok_after = next(
|
||||
(a.finished for a in window if a.ok and a.finished > last_error), end
|
||||
)
|
||||
recovery = first_ok_after - errors[0].finished
|
||||
else:
|
||||
recovery = 0.0
|
||||
oks = [a.finished for a in window if a.ok and a.finished <= end]
|
||||
gap = max((b - a for a, b in zip(oks, oks[1:])), default=None)
|
||||
return {
|
||||
"write_errors": len(errors),
|
||||
"error_kinds": kinds,
|
||||
"write_recovery_seconds": round(recovery, 3),
|
||||
"max_write_gap_seconds": None if gap is None else round(gap, 3),
|
||||
}
|
||||
|
||||
|
||||
def timeline(attempts: list[Attempt], end: float) -> list[dict]:
|
||||
rows = []
|
||||
for second in range(int(end) + 1):
|
||||
inside = [a for a in attempts if second <= a.finished < second + 1]
|
||||
instances: dict[str, int] = {}
|
||||
for a in inside:
|
||||
if a.ok and a.instance:
|
||||
instances[a.instance] = instances.get(a.instance, 0) + 1
|
||||
rows.append(
|
||||
{
|
||||
"t": second,
|
||||
"ok": sum(a.ok for a in inside),
|
||||
"errors": sum(not a.ok for a in inside),
|
||||
"instances": instances,
|
||||
}
|
||||
)
|
||||
return rows
|
||||
|
||||
|
||||
def read_history(client: Client, actor: dict, chat_id: str) -> list[dict]:
|
||||
path = f"/api/v1/chats/{chat_id}/messages?limit=100"
|
||||
items: list[dict] = []
|
||||
while True:
|
||||
page = client.call("GET", path, actor=actor, schema="MessagePage")["json"]
|
||||
items.extend(page["items"])
|
||||
if page["next_cursor"] is None:
|
||||
return items
|
||||
path = f"/api/v1/chats/{chat_id}/messages?limit=100&cursor=" + quote(
|
||||
page["next_cursor"], safe=""
|
||||
)
|
||||
|
||||
|
||||
def integrity(client: Client, actor: dict, chat_id: str, recorder: Recorder) -> dict:
|
||||
history = read_history(client, actor, chat_id)
|
||||
by_id = {m["id"]: m for m in history}
|
||||
texts = [m["text"] for m in history]
|
||||
confirmed = {m["id"]: m for m in recorder.confirmed}
|
||||
return {
|
||||
"messages_in_history": len(history),
|
||||
"confirmed_unique": len(confirmed),
|
||||
"confirmed_missing_or_changed": sum(
|
||||
by_id.get(i) != m for i, m in confirmed.items()
|
||||
),
|
||||
"duplicate_ids": len(history) - len(by_id),
|
||||
"duplicate_texts": len(texts) - len(set(texts)),
|
||||
"retried_writes_confirmed_as_replay": len(recorder.confirmed) - len(confirmed),
|
||||
}
|
||||
|
||||
|
||||
def run(command: list[str], env: dict | None = None) -> str:
|
||||
result = subprocess.run(
|
||||
command, cwd=ROOT, env=env, check=True, capture_output=True, text=True
|
||||
)
|
||||
return result.stdout.strip()
|
||||
|
||||
|
||||
def api_containers() -> list[str]:
|
||||
ids = run(["docker", "compose", "--env-file", ".env", "ps", "-q", "api"]).split()
|
||||
names = [run(["docker", "inspect", "-f", "{{.Name}}", i]).lstrip("/") for i in ids]
|
||||
return sorted(names)
|
||||
|
||||
|
||||
def instance_of(container: str) -> str:
|
||||
return run(["docker", "exec", container, "cat", "/tmp/instance-id"])
|
||||
|
||||
|
||||
def container_stats() -> list[str]:
|
||||
names = ["messenger-lab3-nginx-1", "messenger-lab3-postgres-1", *api_containers()]
|
||||
output = run(["docker", "stats", "--no-stream", "--format", STATS_FORMAT, *names])
|
||||
return output.splitlines()
|
||||
|
||||
|
||||
def scenario(
|
||||
args: argparse.Namespace,
|
||||
label: str,
|
||||
action: list[str],
|
||||
restore: list[str] | None,
|
||||
target: str | None = None,
|
||||
env: dict | None = None,
|
||||
) -> dict:
|
||||
client = Client(args.base_url, timeout=REQUEST_TIMEOUT_SEC)
|
||||
alice, _, _, chat = client.bootstrap()
|
||||
base = client.base
|
||||
recorder = Recorder()
|
||||
stop = threading.Event()
|
||||
threads = [
|
||||
threading.Thread(
|
||||
target=worker,
|
||||
args=(base, alice["token"], chat["id"], n, recorder, stop),
|
||||
daemon=True,
|
||||
)
|
||||
for n in range(args.workers)
|
||||
]
|
||||
for thread in threads:
|
||||
thread.start()
|
||||
time.sleep(args.before / 2)
|
||||
stats = container_stats()
|
||||
time.sleep(args.before / 2)
|
||||
|
||||
instances_before = sorted(
|
||||
{a.instance for a in recorder.attempts if a.ok and a.instance}
|
||||
)
|
||||
recorder.mark("action_start")
|
||||
action_output = run(action, env)
|
||||
recorder.mark("action_end")
|
||||
restore_output = ""
|
||||
if restore is not None:
|
||||
time.sleep(args.outage)
|
||||
recorder.mark("restore_start")
|
||||
restore_output = run(restore)
|
||||
recorder.mark("restore_end")
|
||||
time.sleep(args.after)
|
||||
stop.set()
|
||||
for thread in threads:
|
||||
thread.join(timeout=REQUEST_TIMEOUT_SEC + 1)
|
||||
recorder.mark("end")
|
||||
|
||||
events = recorder.events
|
||||
end = events["end"]
|
||||
after_start = events.get("restore_end", events["action_end"])
|
||||
attempts = recorder.attempts
|
||||
seen_after = [
|
||||
a for a in attempts if a.ok and a.finished >= after_start and a.instance
|
||||
]
|
||||
back_in_rotation = next(
|
||||
(
|
||||
round(a.finished - after_start, 3)
|
||||
for a in sorted(seen_after, key=lambda a: a.finished)
|
||||
if a.instance not in instances_before
|
||||
),
|
||||
None,
|
||||
)
|
||||
served = sorted(
|
||||
(a for a in attempts if a.ok and a.instance), key=lambda a: a.finished
|
||||
)
|
||||
instances_seen: dict[str, list[float]] = {}
|
||||
for a in served:
|
||||
offset = round(a.finished - events["action_start"], 3)
|
||||
instances_seen.setdefault(a.instance, [offset, offset])[1] = offset
|
||||
phases = {
|
||||
"before": phase_stats(attempts, 0, events["action_start"]),
|
||||
"during": phase_stats(attempts, events["action_start"], after_start),
|
||||
"after": phase_stats(attempts, after_start, end),
|
||||
}
|
||||
target_after_stop = None
|
||||
if target is not None:
|
||||
target_after_stop = sum(
|
||||
1
|
||||
for a in attempts
|
||||
if a.ok
|
||||
and a.instance == target
|
||||
and a.finished > events["action_end"]
|
||||
and a.finished < events.get("restore_start", end)
|
||||
)
|
||||
return {
|
||||
"scenario": label,
|
||||
"target_instance": target,
|
||||
"workers": args.workers,
|
||||
"events_seconds": events,
|
||||
"instances_before": instances_before,
|
||||
"instances_after": sorted({a.instance for a in seen_after}),
|
||||
"target_responses_while_stopped": target_after_stop,
|
||||
"restored_replica_in_rotation_seconds": back_in_rotation
|
||||
if restore is not None
|
||||
else None,
|
||||
# alias → [первый, последний] успешный ответ, секунды от начала воздействия
|
||||
"instances_seen_from_action": instances_seen,
|
||||
"phases": phases,
|
||||
"recovery": recovery_stats(attempts, events["action_start"], end),
|
||||
"integrity": integrity(client, alice, chat["id"], recorder),
|
||||
"container_stats_before_action": stats,
|
||||
"action_output": action_output.splitlines(),
|
||||
"restore_output_tail": restore_output.splitlines()[-2:],
|
||||
"timeline": timeline(attempts, end),
|
||||
}
|
||||
|
||||
|
||||
def failover(args: argparse.Namespace) -> list[dict]:
|
||||
results = []
|
||||
for signal in args.signals:
|
||||
for container in api_containers():
|
||||
target = instance_of(container)
|
||||
if signal == "SIGTERM":
|
||||
action = ["docker", "stop", "--timeout", "10", container]
|
||||
else:
|
||||
action = ["docker", "kill", "--signal", "SIGKILL", container]
|
||||
label = f"{signal} {container}"
|
||||
print(f"== {label} (instance {target})", flush=True)
|
||||
result = scenario(
|
||||
args, label, action, ["./scripts/restore.sh"], target=target
|
||||
)
|
||||
print(json.dumps(brief(result), ensure_ascii=False), flush=True)
|
||||
results.append(result)
|
||||
return results
|
||||
|
||||
|
||||
def rolling(args: argparse.Namespace) -> list[dict]:
|
||||
env = dict(os.environ)
|
||||
env.setdefault("APP_REVISION", f"exp-{int(time.time())}")
|
||||
print(f"== rolling update to revision {env['APP_REVISION']}", flush=True)
|
||||
result = scenario(
|
||||
args, "rolling update", ["./scripts/rolling-update.sh"], None, env=env
|
||||
)
|
||||
result["revisions_after"] = run(["./scripts/instances.sh"]).splitlines()
|
||||
print(json.dumps(brief(result), ensure_ascii=False), flush=True)
|
||||
return [result]
|
||||
|
||||
|
||||
def brief(result: dict) -> dict:
|
||||
"""Краткая строка прогона для терминала; полная версия — в --output"""
|
||||
return {
|
||||
"scenario": result["scenario"],
|
||||
"rps_ok_write": {k: v["write"]["ok_rps"] for k, v in result["phases"].items()},
|
||||
"rps_ok_read": {k: v["read"]["ok_rps"] for k, v in result["phases"].items()},
|
||||
"errors": {
|
||||
k: v["write"]["errors"] + v["read"]["errors"]
|
||||
for k, v in result["phases"].items()
|
||||
},
|
||||
"recovery": result["recovery"],
|
||||
"target_responses_while_stopped": result["target_responses_while_stopped"],
|
||||
"restored_replica_in_rotation_seconds": result[
|
||||
"restored_replica_in_rotation_seconds"
|
||||
],
|
||||
"instances_seen_from_action": result["instances_seen_from_action"],
|
||||
"integrity": result["integrity"],
|
||||
}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("mode", choices=["failover", "rolling"])
|
||||
parser.add_argument("--base-url", default=None)
|
||||
parser.add_argument("--workers", type=int, default=4)
|
||||
parser.add_argument("--before", type=float, default=8, help="нагрузка до отказа")
|
||||
parser.add_argument("--outage", type=float, default=10, help="реплика остановлена")
|
||||
parser.add_argument("--after", type=float, default=8, help="после восстановления")
|
||||
parser.add_argument(
|
||||
"--signals",
|
||||
nargs="+",
|
||||
default=["SIGTERM", "SIGKILL"],
|
||||
choices=["SIGTERM", "SIGKILL"],
|
||||
)
|
||||
parser.add_argument("--output", default=None, help="JSON с полными результатами")
|
||||
args = parser.parse_args()
|
||||
started = time.strftime("%Y-%m-%dT%H:%M:%S%z")
|
||||
results = failover(args) if args.mode == "failover" else rolling(args)
|
||||
report = {
|
||||
"mode": args.mode,
|
||||
"started": started,
|
||||
"profile": {
|
||||
"workers": args.workers,
|
||||
"loop": "closed: POST message (retry same key until 201) + GET limit=1",
|
||||
"client_timeout_seconds": REQUEST_TIMEOUT_SEC,
|
||||
"phases_seconds": {
|
||||
"before": args.before,
|
||||
"outage": args.outage,
|
||||
"after": args.after,
|
||||
},
|
||||
},
|
||||
"runs": results,
|
||||
}
|
||||
if args.output:
|
||||
destination = ROOT / args.output
|
||||
destination.parent.mkdir(parents=True, exist_ok=True)
|
||||
destination.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
|
||||
print(f"saved: {args.output}")
|
||||
failed = [
|
||||
r["scenario"]
|
||||
for r in results
|
||||
if r["integrity"]["confirmed_missing_or_changed"]
|
||||
or r["integrity"]["duplicate_ids"]
|
||||
or r["integrity"]["duplicate_texts"]
|
||||
or r["target_responses_while_stopped"]
|
||||
]
|
||||
if failed:
|
||||
raise SystemExit(f"FAIL: потеря/дубль или отказ не изолирован: {failed}")
|
||||
print(f"PASS: прогонов {len(results)}, подтверждённые сообщения целы, дублей нет")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,111 @@
|
||||
-- Обоснование индекса истории: EXPLAIN (ANALYZE, BUFFERS) на ≥10 000 сообщений.
|
||||
-- Запуск: make explain → evidence/explain_history.txt
|
||||
-- Сид синтетический и идемпотентный: повторный запуск данных не дублирует.
|
||||
-- Пользователь explain_seed не может войти: password_hash не является hash Argon2.
|
||||
|
||||
\pset pager off
|
||||
\timing off
|
||||
|
||||
DO $$
|
||||
DECLARE
|
||||
seed_user uuid;
|
||||
big_chat uuid;
|
||||
noise uuid;
|
||||
BEGIN
|
||||
IF EXISTS (SELECT 1 FROM chats WHERE title = 'explain-big') THEN
|
||||
RETURN;
|
||||
END IF;
|
||||
|
||||
INSERT INTO users (username, display_name, password_hash)
|
||||
VALUES ('explain_seed', 'EXPLAIN seed', 'not-an-argon2-hash')
|
||||
ON CONFLICT (username) DO UPDATE SET display_name = EXCLUDED.display_name
|
||||
RETURNING id INTO seed_user;
|
||||
|
||||
-- Большой чат: 20 000 сообщений
|
||||
INSERT INTO chats (title, created_by) VALUES ('explain-big', seed_user)
|
||||
RETURNING id INTO big_chat;
|
||||
INSERT INTO chat_members (chat_id, user_id, position) VALUES (big_chat, seed_user, 0);
|
||||
INSERT INTO messages (chat_id, sender_id, text, created_at)
|
||||
SELECT big_chat, seed_user, 'synthetic message #' || n,
|
||||
timestamptz '2026-01-01 00:00:00+00' + n * interval '1 second'
|
||||
FROM generate_series(1, 20000) AS n;
|
||||
|
||||
-- Шум: 50 чатов по 1 000 сообщений, чтобы таблица была больше одного чата
|
||||
FOR i IN 1..50 LOOP
|
||||
INSERT INTO chats (title, created_by) VALUES ('explain-noise-' || i, seed_user)
|
||||
RETURNING id INTO noise;
|
||||
INSERT INTO chat_members (chat_id, user_id, position) VALUES (noise, seed_user, 0);
|
||||
INSERT INTO messages (chat_id, sender_id, text, created_at)
|
||||
SELECT noise, seed_user, 'noise #' || n,
|
||||
timestamptz '2026-01-01 00:00:00+00' + n * interval '1 second'
|
||||
FROM generate_series(1, 1000) AS n;
|
||||
END LOOP;
|
||||
END $$;
|
||||
|
||||
ANALYZE users, chats, chat_members, messages;
|
||||
|
||||
SELECT id AS big_chat FROM chats WHERE title = 'explain-big' \gset
|
||||
|
||||
-- Cursor из середины истории: ключ 10 000-го сообщения
|
||||
SELECT created_at AS cursor_created_at, id AS cursor_id
|
||||
FROM messages WHERE chat_id = :'big_chat'
|
||||
ORDER BY created_at, id OFFSET 9999 LIMIT 1 \gset
|
||||
|
||||
\echo '== Объём данных'
|
||||
SELECT
|
||||
(SELECT count(*) FROM messages) AS messages_total,
|
||||
(SELECT count(*) FROM messages WHERE chat_id = :'big_chat') AS messages_in_big_chat,
|
||||
pg_size_pretty(pg_relation_size('messages')) AS messages_heap,
|
||||
pg_size_pretty(pg_relation_size('messages_chat_id_created_at_id_idx')) AS history_index;
|
||||
|
||||
\echo ''
|
||||
\echo '== 1. Первая страница истории (limit 50 + 1), как list_for_chat'
|
||||
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = :'big_chat'
|
||||
ORDER BY created_at, id
|
||||
LIMIT 51;
|
||||
|
||||
\echo ''
|
||||
\echo '== 2. Страница из середины по cursor (после 10 000-го), как list_for_chat_after'
|
||||
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = :'big_chat'
|
||||
AND (created_at, id) > (:'cursor_created_at'::timestamptz, :'cursor_id'::uuid)
|
||||
ORDER BY created_at, id
|
||||
LIMIT 51;
|
||||
|
||||
\echo ''
|
||||
\echo '== 3. Тот же запрос как generic plan prepared statement (так его исполняет asyncpg)'
|
||||
SET plan_cache_mode = force_generic_plan;
|
||||
PREPARE history_page(uuid, timestamptz, uuid, int) AS
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
ORDER BY created_at, id
|
||||
LIMIT $4;
|
||||
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
|
||||
EXECUTE history_page(:'big_chat', :'cursor_created_at', :'cursor_id', 51);
|
||||
DEALLOCATE history_page;
|
||||
RESET plan_cache_mode;
|
||||
|
||||
\echo ''
|
||||
\echo '== 4. MAX(created_at) при вставке сообщения (монотонное время чата)'
|
||||
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
|
||||
SELECT max(created_at) FROM messages WHERE chat_id = :'big_chat';
|
||||
|
||||
\echo ''
|
||||
\echo '== 5. Для сравнения: тот же запрос из середины БЕЗ индекса истории'
|
||||
\echo ' (DROP INDEX внутри транзакции с ROLLBACK — индекс не теряется)'
|
||||
BEGIN;
|
||||
DROP INDEX messages_chat_id_created_at_id_idx;
|
||||
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = :'big_chat'
|
||||
AND (created_at, id) > (:'cursor_created_at'::timestamptz, :'cursor_id'::uuid)
|
||||
ORDER BY created_at, id
|
||||
LIMIT 51;
|
||||
ROLLBACK;
|
||||
Executable
+73
@@ -0,0 +1,73 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Локальные синтетические секреты стенда в secrets/ (каталог в .gitignore)
|
||||
# и .env из .env.example, если их ещё нет. Повторный запуск ничего не меняет:
|
||||
# существующие ключи не перезаписываются, иначе данные bucket станут недоступны.
|
||||
#
|
||||
# s3_admin_* — ключи s3-bootstrap: создание bucket (действие Admin)
|
||||
# s3_access_* — ключи API и janitor: Read/Write/List только своего bucket
|
||||
# s3_identities — конфигурация identities SeaweedFS из этих ключей
|
||||
#
|
||||
# Значения не печатаются. Файлы 0644 внутри каталога 0700: процесс API в
|
||||
# контейнере работает не от root и должен прочитать смонтированный секрет.
|
||||
cd "$(dirname "$0")/.."
|
||||
umask 077
|
||||
|
||||
if [ ! -f .env ]; then
|
||||
cp .env.example .env
|
||||
echo "created .env from .env.example"
|
||||
fi
|
||||
|
||||
BUCKET=$(sed -n 's/^S3_BUCKET=//p' .env)
|
||||
: "${BUCKET:?S3_BUCKET is not set in .env}"
|
||||
|
||||
mkdir -p secrets
|
||||
chmod 700 secrets
|
||||
|
||||
random() {
|
||||
LC_ALL=C tr -dc 'A-Za-z0-9' </dev/urandom | head -c "$1"
|
||||
}
|
||||
|
||||
secret() {
|
||||
file="secrets/$1"
|
||||
if [ ! -s "$file" ]; then
|
||||
random "$2" >"$file"
|
||||
echo "created $file"
|
||||
fi
|
||||
chmod 644 "$file"
|
||||
}
|
||||
|
||||
secret s3_admin_access_key_id 20
|
||||
secret s3_admin_secret_access_key 40
|
||||
secret s3_access_key_id 20
|
||||
secret s3_secret_access_key 40
|
||||
|
||||
# Без identity "anonymous" SeaweedFS отклоняет любой неподписанный запрос
|
||||
cat >secrets/s3_identities.json <<EOF
|
||||
{
|
||||
"identities": [
|
||||
{
|
||||
"name": "bootstrap",
|
||||
"credentials": [
|
||||
{
|
||||
"accessKey": "$(cat secrets/s3_admin_access_key_id)",
|
||||
"secretKey": "$(cat secrets/s3_admin_secret_access_key)"
|
||||
}
|
||||
],
|
||||
"actions": ["Admin"]
|
||||
},
|
||||
{
|
||||
"name": "messenger-api",
|
||||
"credentials": [
|
||||
{
|
||||
"accessKey": "$(cat secrets/s3_access_key_id)",
|
||||
"secretKey": "$(cat secrets/s3_secret_access_key)"
|
||||
}
|
||||
],
|
||||
"actions": ["Read:$BUCKET", "Write:$BUCKET", "List:$BUCKET"]
|
||||
}
|
||||
]
|
||||
}
|
||||
EOF
|
||||
chmod 644 secrets/s3_identities.json
|
||||
echo "secrets ready in secrets/ (values are not printed)"
|
||||
Executable
+17
@@ -0,0 +1,17 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Операторский вид API-реплик: контейнер ↔ alias X-Instance-Id ↔ ревизия образа.
|
||||
# Нужен, чтобы показать, какой реальный контейнер обслужил запрос или остановлен:
|
||||
# заголовок сам по себе не доказывает разные процессы.
|
||||
cd "$(dirname "$0")/.."
|
||||
ENV_FILE="${ENV_FILE:-.env}"
|
||||
|
||||
printf '%-24s %-28s %-14s %-8s %s\n' CONTAINER STATE INSTANCE PID REVISION
|
||||
for container in $(docker compose --env-file "$ENV_FILE" ps -a -q api); do
|
||||
name=$(docker inspect -f '{{.Name}}' "$container")
|
||||
state=$(docker inspect -f '{{.State.Status}}{{if .State.Health}}/{{.State.Health.Status}}{{end}}' "$container")
|
||||
pid=$(docker inspect -f '{{.State.Pid}}' "$container")
|
||||
revision=$(docker inspect -f '{{index .Config.Labels "org.opencontainers.image.revision"}}' "$container")
|
||||
alias=$(docker exec "$container" cat /tmp/instance-id 2>/dev/null || echo -)
|
||||
printf '%-24s %-28s %-14s %-8s %s\n' "${name#/}" "$state" "$alias" "$pid" "$revision"
|
||||
done
|
||||
Executable
+12
@@ -0,0 +1,12 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Перезапуск всего стенда с сохранением volumes: хранилища (PostgreSQL, Valkey,
|
||||
# S3), затем все API-реплики, janitor и балансировщик. Никаких down -v, flush
|
||||
# или повторного seed; migrate и s3-bootstrap не запускаются — схема и bucket
|
||||
# уже в volumes. Готовность ждёт тест.
|
||||
cd "$(dirname "$0")/.."
|
||||
ENV_FILE="${ENV_FILE:-.env}"
|
||||
|
||||
docker compose --env-file "$ENV_FILE" restart --no-deps postgres valkey s3
|
||||
docker compose --env-file "$ENV_FILE" restart --no-deps api janitor
|
||||
docker compose --env-file "$ENV_FILE" restart --no-deps nginx
|
||||
Executable
+9
@@ -0,0 +1,9 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Возврат API-реплик к числу API_REPLICAS после stop-one.sh: запуск остановленных
|
||||
# контейнеров и ожидание healthy. Работающие реплики не пересоздаются
|
||||
# (--no-recreate), хранилища, migrate и LB не перезапускаются.
|
||||
cd "$(dirname "$0")/.."
|
||||
ENV_FILE="${ENV_FILE:-.env}"
|
||||
|
||||
docker compose --env-file "$ENV_FILE" up -d --no-deps --no-recreate --wait --wait-timeout 60 api
|
||||
Executable
+42
@@ -0,0 +1,42 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Поочерёдная замена API-реплик новой сборкой без остановки обслуживания.
|
||||
# 1. build нового образа (ревизия видна в метке образа и журнале старта);
|
||||
# 2. migrate однократно: миграции только расширяют схему, старые реплики
|
||||
# продолжают работать на новой схеме;
|
||||
# 3. для каждой старой реплики: +1 новая → ждать healthy → пауза на обновление
|
||||
# DNS в nginx → graceful stop старой (SIGTERM, LB уводит трафик) → удалить.
|
||||
# Во время замены реплик на одну больше, чем API_REPLICAS: ресурс заложен заранее.
|
||||
cd "$(dirname "$0")/.."
|
||||
ENV_FILE="${ENV_FILE:-.env}"
|
||||
COMPOSE="docker compose --env-file $ENV_FILE"
|
||||
APP_REVISION="${APP_REVISION:-$(git rev-parse --short HEAD 2>/dev/null || echo dev)-$(date +%s)}"
|
||||
export APP_REVISION
|
||||
# ID образа зависит только от содержимого (без provenance-attestation)
|
||||
export BUILDX_NO_DEFAULT_ATTESTATIONS=1
|
||||
# Больше resolver valid=2s в nginx: новая реплика уже в upstream до остановки старой
|
||||
LB_DNS_REFRESH_SEC=3
|
||||
STOP_TIMEOUT_SEC=10
|
||||
|
||||
log() {
|
||||
echo "[$(date +%H:%M:%S)] $*"
|
||||
}
|
||||
|
||||
log "build revision $APP_REVISION"
|
||||
$COMPOSE build --quiet api
|
||||
log "migrate"
|
||||
$COMPOSE run --rm --no-deps migrate >/dev/null
|
||||
|
||||
old_containers=$($COMPOSE ps -q api)
|
||||
for container in $old_containers; do
|
||||
name=$(docker inspect -f '{{.Name}}' "$container")
|
||||
running=$($COMPOSE ps -q api | wc -l | tr -d ' ')
|
||||
log "scale api to $((running + 1)), wait healthy"
|
||||
$COMPOSE up -d --no-deps --no-recreate --wait --wait-timeout 60 \
|
||||
--scale "api=$((running + 1))" api
|
||||
sleep "$LB_DNS_REFRESH_SEC"
|
||||
log "graceful stop ${name#/}"
|
||||
docker stop --timeout "$STOP_TIMEOUT_SEC" "$container" >/dev/null
|
||||
docker rm "$container" >/dev/null
|
||||
done
|
||||
log "done: all API replicas run revision $APP_REVISION"
|
||||
Executable
+114
@@ -0,0 +1,114 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Временный read-only доступ к Filer UI SeaweedFS (просмотр бакетов) с хоста.
|
||||
|
||||
Filer UI слушает только 127.0.0.1 внутри контейнера s3 и в сеть не открыт
|
||||
(требование: административная консоль не доступна в общей сети). Этот скрипт
|
||||
— операторский инструмент на время демонстрации:
|
||||
|
||||
* слушает только 127.0.0.1 хоста и живёт, пока запущен (Ctrl+C — закрыть);
|
||||
* пропускает только GET/HEAD: удаление/загрузка через UI (POST/PUT/DELETE)
|
||||
отклоняются 405, данные bucket через него не изменить;
|
||||
* каждый запрос выполняется в контейнере s3 (docker exec … curl) к
|
||||
127.0.0.1:8888 — порты контейнера и сети стенда не меняются.
|
||||
|
||||
make s3-ui # http://127.0.0.1:8888/buckets/
|
||||
python3 scripts/s3_ui.py --port 18888
|
||||
|
||||
Python 3.9+, стандартная библиотека.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import subprocess
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
FILER_URL = "http://127.0.0.1:8888"
|
||||
CURL_TIMEOUT_SEC = 30
|
||||
# Заголовки клиента, передаваемые filer: от Accept зависит HTML или JSON
|
||||
FORWARDED_HEADERS = ("Accept", "Range")
|
||||
# Ответ пересобирается целиком: длина и кодирование задаются заново
|
||||
DROPPED_HEADERS = {"transfer-encoding", "connection", "content-length", "keep-alive"}
|
||||
|
||||
|
||||
def s3_container() -> str:
|
||||
container = subprocess.run(
|
||||
["docker", "compose", "--env-file", ".env", "ps", "-q", "s3"],
|
||||
cwd=ROOT,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
check=True,
|
||||
).stdout.strip()
|
||||
if not container:
|
||||
raise SystemExit("контейнер s3 не запущен: сначала make up")
|
||||
return container
|
||||
|
||||
|
||||
class ReadOnlyFilerProxy(BaseHTTPRequestHandler):
|
||||
container = ""
|
||||
|
||||
def do_GET(self) -> None:
|
||||
self._proxy(head=False)
|
||||
|
||||
def do_HEAD(self) -> None:
|
||||
self._proxy(head=True)
|
||||
|
||||
def _reject(self) -> None:
|
||||
self.send_error(405, "Read-only: изменение bucket через UI запрещено")
|
||||
|
||||
do_POST = do_PUT = do_DELETE = do_PATCH = _reject
|
||||
|
||||
def _proxy(self, head: bool) -> None:
|
||||
command = ["docker", "exec", self.container, "curl", "-s", "-i"]
|
||||
if head:
|
||||
command.append("-I")
|
||||
for name in FORWARDED_HEADERS:
|
||||
if self.headers.get(name):
|
||||
command += ["-H", f"{name}: {self.headers[name]}"]
|
||||
command.append(FILER_URL + self.path)
|
||||
try:
|
||||
raw = subprocess.run(
|
||||
command, capture_output=True, timeout=CURL_TIMEOUT_SEC, check=True
|
||||
).stdout
|
||||
except (subprocess.SubprocessError, OSError):
|
||||
self.send_error(502, "Filer недоступен")
|
||||
return
|
||||
head_part, _, body = raw.partition(b"\r\n\r\n")
|
||||
lines = head_part.decode("latin-1").split("\r\n")
|
||||
status = int(lines[0].split()[1])
|
||||
self.send_response(status)
|
||||
for line in lines[1:]:
|
||||
name, _, value = line.partition(":")
|
||||
if name.strip().lower() not in DROPPED_HEADERS:
|
||||
self.send_header(name.strip(), value.strip())
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.send_header("Connection", "close")
|
||||
self.end_headers()
|
||||
if not head:
|
||||
self.wfile.write(body)
|
||||
|
||||
def log_message(self, format: str, *args: object) -> None:
|
||||
print(f"{self.command} {self.path.split('?')[0]} -> {args[1] if len(args) > 1 else ''}")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||||
parser.add_argument("--port", type=int, default=8888)
|
||||
args = parser.parse_args()
|
||||
|
||||
ReadOnlyFilerProxy.container = s3_container()
|
||||
server = ThreadingHTTPServer(("127.0.0.1", args.port), ReadOnlyFilerProxy)
|
||||
print(f"Filer UI (read-only): http://127.0.0.1:{args.port}/buckets/ — Ctrl+C, чтобы закрыть")
|
||||
try:
|
||||
server.serve_forever()
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
finally:
|
||||
server.server_close()
|
||||
print("проброс закрыт")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,148 @@
|
||||
#!/usr/bin/env python3
|
||||
"""SIGTERM одной API-реплики за балансировщиком.
|
||||
|
||||
Реплика перестаёт принимать соединения, дожидается текущих запросов и
|
||||
завершается не дольше чем за 10 секунд; LB уводит трафик на другие реплики.
|
||||
Во время проверки фоновые клиенты непрерывно шлют GET /health/live через LB:
|
||||
ошибок (5xx/обрыв) быть не должно, после выхода реплики её X-Instance-Id
|
||||
в ответах не появляется.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import threading
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
DEFAULT_BASE_URL = json.loads((ROOT / "lab.json").read_text())["default_base_url"]
|
||||
|
||||
SHUTDOWN_LIMIT_SEC = 10
|
||||
PROBE_INTERVAL_SEC = 0.02
|
||||
PROBERS = 4
|
||||
|
||||
|
||||
class Prober(threading.Thread):
|
||||
"""Фоновый клиент через LB: время ответа и обслужившая реплика"""
|
||||
|
||||
def __init__(self, url: str) -> None:
|
||||
super().__init__(daemon=True)
|
||||
self.url = url
|
||||
self.stop = threading.Event()
|
||||
self.ok: list[tuple[float, str]] = []
|
||||
self.errors: list[tuple[float, str]] = []
|
||||
|
||||
def run(self) -> None:
|
||||
while not self.stop.is_set():
|
||||
try:
|
||||
with urllib.request.urlopen(self.url, timeout=2) as response:
|
||||
self.ok.append(
|
||||
(time.monotonic(), response.headers.get("X-Instance-Id", ""))
|
||||
)
|
||||
except urllib.error.HTTPError as error:
|
||||
self.errors.append((time.monotonic(), f"HTTP {error.code}"))
|
||||
except OSError as error:
|
||||
self.errors.append((time.monotonic(), type(error).__name__))
|
||||
time.sleep(PROBE_INTERVAL_SEC)
|
||||
|
||||
|
||||
def docker(*args: str) -> str:
|
||||
result = subprocess.run(
|
||||
["docker", *args], check=True, capture_output=True, text=True
|
||||
)
|
||||
return result.stdout.strip()
|
||||
|
||||
|
||||
def first_api_container() -> str:
|
||||
ids = docker("compose", "--env-file", ".env", "ps", "-q", "api").split()
|
||||
if not ids:
|
||||
raise SystemExit("FAIL: нет запущенных API-реплик")
|
||||
return docker("inspect", "-f", "{{.Name}}", ids[0]).lstrip("/")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument(
|
||||
"--base-url", default=os.environ.get("BASE_URL") or DEFAULT_BASE_URL
|
||||
)
|
||||
parser.add_argument("--container", default=os.environ.get("CONTAINER"))
|
||||
args = parser.parse_args()
|
||||
os.chdir(ROOT)
|
||||
container = args.container or first_api_container()
|
||||
instance = docker("exec", container, "cat", "/tmp/instance-id")
|
||||
|
||||
logs = subprocess.Popen(
|
||||
["docker", "logs", "--follow", "--since", "0s", container],
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.STDOUT,
|
||||
text=True,
|
||||
)
|
||||
waiter = subprocess.Popen(
|
||||
["docker", "wait", container], stdout=subprocess.PIPE, text=True
|
||||
)
|
||||
probers = [
|
||||
Prober(args.base_url.rstrip("/") + "/health/live") for _ in range(PROBERS)
|
||||
]
|
||||
for prober in probers:
|
||||
prober.start()
|
||||
time.sleep(1)
|
||||
before = {alias for prober in probers for _, alias in prober.ok}
|
||||
if instance not in before:
|
||||
raise SystemExit("FAIL: целевая реплика не обслуживает запросы до SIGTERM")
|
||||
|
||||
sent_at = time.monotonic()
|
||||
docker("kill", "--signal", "SIGTERM", container)
|
||||
exit_code = int(waiter.communicate(timeout=SHUTDOWN_LIMIT_SEC + 5)[0].strip())
|
||||
exited_at = time.monotonic()
|
||||
time.sleep(1)
|
||||
for prober in probers:
|
||||
prober.stop.set()
|
||||
prober.join()
|
||||
logs.terminate()
|
||||
shutdown_log = logs.communicate(timeout=5)[0]
|
||||
|
||||
ok_after = [(t, a) for p in probers for t, a in p.ok if t > sent_at]
|
||||
errors_after = [(t, e) for p in probers for t, e in p.errors if t > sent_at]
|
||||
target_after_exit = [t for t, a in ok_after if a == instance and t > exited_at]
|
||||
last_target = max((t for t, a in ok_after if a == instance), default=None)
|
||||
print("Журнал реплики после SIGTERM:")
|
||||
print(
|
||||
"\n".join(line for line in shutdown_log.splitlines() if "/health/" not in line)
|
||||
)
|
||||
summary = {
|
||||
"container": container,
|
||||
"instance": instance,
|
||||
"exit_code": exit_code,
|
||||
"shutdown_seconds": round(exited_at - sent_at, 3),
|
||||
"limit_seconds": SHUTDOWN_LIMIT_SEC,
|
||||
"instances_before": sorted(before),
|
||||
"probes_ok_after_sigterm": len(ok_after),
|
||||
"instances_after_sigterm": sorted({a for _, a in ok_after}),
|
||||
"last_target_response_after_sigterm_seconds": None
|
||||
if last_target is None
|
||||
else round(last_target - sent_at, 3),
|
||||
"target_responses_after_exit": len(target_after_exit),
|
||||
"errors_after_sigterm": len(errors_after),
|
||||
"error_kinds": sorted({e for _, e in errors_after}),
|
||||
}
|
||||
print(json.dumps(summary, indent=2, ensure_ascii=False))
|
||||
if (
|
||||
exit_code != 0
|
||||
or exited_at - sent_at > SHUTDOWN_LIMIT_SEC
|
||||
or errors_after
|
||||
or target_after_exit
|
||||
or not ok_after
|
||||
):
|
||||
raise SystemExit("FAIL: завершение по SIGTERM не соответствует требованиям")
|
||||
print(
|
||||
"PASS: SIGTERM завершил %s за %.2f с, LB обслужил %d запросов без ошибок"
|
||||
% (container, exited_at - sent_at, len(ok_after))
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+24
@@ -0,0 +1,24 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Остановка ОДНОЙ API-реплики, обслужившей тест: TARGET_INSTANCE_ID → контейнер.
|
||||
# Каждый процесс API пишет свой alias (X-Instance-Id) в /tmp/instance-id.
|
||||
# docker stop: SIGTERM → graceful shutdown; restart-политика unless-stopped
|
||||
# не поднимает вручную остановленный контейнер, он остаётся остановленным.
|
||||
# БД, LB и volumes не затрагиваются. Восстановление — scripts/restore.sh.
|
||||
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
|
||||
cd "$(dirname "$0")/.."
|
||||
ENV_FILE="${ENV_FILE:-.env}"
|
||||
# Меньше 10 с лимита hook; больше drain + graceful shutdown (1 + 5 с)
|
||||
STOP_TIMEOUT_SEC=8
|
||||
|
||||
for container in $(docker compose --env-file "$ENV_FILE" ps -q api); do
|
||||
alias=$(docker exec "$container" cat /tmp/instance-id 2>/dev/null || true)
|
||||
if [ "$alias" = "$TARGET_INSTANCE_ID" ]; then
|
||||
name=$(docker inspect -f '{{.Name}}' "$container")
|
||||
docker stop --timeout "$STOP_TIMEOUT_SEC" "$container" >/dev/null
|
||||
echo "stopped ${name#/} (instance $alias)" >&2
|
||||
exit 0
|
||||
fi
|
||||
done
|
||||
echo "no running API replica with instance $TARGET_INSTANCE_ID" >&2
|
||||
exit 1
|
||||
@@ -0,0 +1,317 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Эксперимент: N одновременных загрузок вложений и пик памяти API-реплик.
|
||||
|
||||
Гипотеза: память реплики на загрузку ограничена (spool ≤ 1 MiB RAM, потоковый
|
||||
PUT в S3, проверка изображения в пуле из IMAGE_INSPECT_WORKERS потоков),
|
||||
поэтому пик RSS растёт не пропорционально N × размер файла.
|
||||
|
||||
Профили:
|
||||
png — PNG ~9 MiB из шума (почти не сжимается): нагрузка на приём тела,
|
||||
spool, SHA-256 и PUT в S3. Генерируется стандартной библиотекой.
|
||||
jpeg — progressive JPEG 8000×5000 = 40 Мпикс (предел): худший случай
|
||||
декодера libjpeg. Нужен Pillow (poetry run python ...).
|
||||
|
||||
Перед каждым прогоном API-реплики перезапускаются: VmHWM (пиковый RSS
|
||||
процесса) начинается заново. Память опрашивается внутри контейнеров каждые
|
||||
0.2 с (cgroup memory.current и VmRSS процесса). Все N запросов стартуют по
|
||||
одному барьеру. Tokens не печатаются и не сохраняются.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import hashlib
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import platform
|
||||
import statistics
|
||||
import struct
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import zlib
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "tests"))
|
||||
|
||||
from client import Client # noqa: E402
|
||||
|
||||
REQUEST_TIMEOUT_SEC = 120
|
||||
READY_TIMEOUT_SEC = 90
|
||||
SAMPLE_INTERVAL_SEC = 0.2
|
||||
COMPOSE = ["docker", "compose", "--env-file", ".env"]
|
||||
SAMPLER = (
|
||||
"while :; do "
|
||||
"echo $(cat /sys/fs/cgroup/memory.current) "
|
||||
"$(awk '/VmRSS/ {print $2}' /proc/1/status); "
|
||||
f"sleep {SAMPLE_INTERVAL_SEC}; done"
|
||||
)
|
||||
|
||||
|
||||
def png_noise(width: int, height: int) -> bytes:
|
||||
"""Настоящий RGB PNG из случайных байт: размер ≈ width × height × 3"""
|
||||
|
||||
def chunk(kind: bytes, data: bytes) -> bytes:
|
||||
return (
|
||||
struct.pack(">I", len(data))
|
||||
+ kind
|
||||
+ data
|
||||
+ struct.pack(">I", zlib.crc32(kind + data))
|
||||
)
|
||||
|
||||
raw = b"".join(b"\x00" + os.urandom(width * 3) for _ in range(height))
|
||||
header = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
|
||||
return (
|
||||
b"\x89PNG\r\n\x1a\n"
|
||||
+ chunk(b"IHDR", header)
|
||||
+ chunk(b"IDAT", zlib.compress(raw, 1))
|
||||
+ chunk(b"IEND", b"")
|
||||
)
|
||||
|
||||
|
||||
def jpeg_worst_case() -> bytes:
|
||||
from PIL import Image
|
||||
|
||||
Image.MAX_IMAGE_PIXELS = None
|
||||
image = Image.effect_noise((8000, 5000), 64).convert("RGB")
|
||||
buffer = io.BytesIO()
|
||||
image.save(buffer, "JPEG", quality=10, progressive=True, subsampling=0)
|
||||
return buffer.getvalue()
|
||||
|
||||
|
||||
def compose(*args: str) -> str:
|
||||
return subprocess.run(
|
||||
[*COMPOSE, *args], cwd=ROOT, capture_output=True, text=True, check=True
|
||||
).stdout
|
||||
|
||||
|
||||
def api_containers() -> list[str]:
|
||||
return compose("ps", "-q", "api").split()
|
||||
|
||||
|
||||
def container_name(container: str) -> str:
|
||||
return subprocess.run(
|
||||
["docker", "inspect", "-f", "{{.Name}}", container],
|
||||
capture_output=True, text=True, check=True,
|
||||
).stdout.strip().lstrip("/")
|
||||
|
||||
|
||||
def process_status(container: str) -> dict:
|
||||
"""VmRSS/VmHWM процесса API (PID 1), байты, и его X-Instance-Id"""
|
||||
output = subprocess.run(
|
||||
["docker", "exec", container, "sh", "-c",
|
||||
"grep -E 'VmRSS|VmHWM' /proc/1/status; cat /tmp/instance-id"],
|
||||
capture_output=True, text=True, check=True,
|
||||
).stdout.split("\n")
|
||||
values: dict = {line.split(":")[0]: int(line.split()[1]) * 1024 for line in output[:2]}
|
||||
values["instance"] = output[2].strip()
|
||||
return values
|
||||
|
||||
|
||||
def restart_api(base_url: str) -> None:
|
||||
compose("restart", "api")
|
||||
deadline = time.monotonic() + READY_TIMEOUT_SEC
|
||||
while time.monotonic() < deadline:
|
||||
states = [
|
||||
subprocess.run(
|
||||
["docker", "inspect", "-f", "{{.State.Health.Status}}", c],
|
||||
capture_output=True, text=True,
|
||||
).stdout.strip()
|
||||
for c in api_containers()
|
||||
]
|
||||
if states and all(state == "healthy" for state in states):
|
||||
return
|
||||
time.sleep(1)
|
||||
raise SystemExit("API replicas are not healthy after restart")
|
||||
|
||||
|
||||
class Sampler(threading.Thread):
|
||||
"""Опрос памяти одного контейнера изнутри одним долгим docker exec"""
|
||||
|
||||
def __init__(self, container: str) -> None:
|
||||
super().__init__(daemon=True)
|
||||
self.container = container
|
||||
self.cgroup_max = 0
|
||||
self.rss_max = 0
|
||||
self.samples = 0
|
||||
self._process = subprocess.Popen(
|
||||
["docker", "exec", container, "sh", "-c", SAMPLER],
|
||||
stdout=subprocess.PIPE, text=True,
|
||||
)
|
||||
|
||||
def run(self) -> None:
|
||||
assert self._process.stdout is not None
|
||||
for line in self._process.stdout:
|
||||
parts = line.split()
|
||||
if len(parts) == 2:
|
||||
self.cgroup_max = max(self.cgroup_max, int(parts[0]))
|
||||
self.rss_max = max(self.rss_max, int(parts[1]) * 1024)
|
||||
self.samples += 1
|
||||
|
||||
def stop(self) -> None:
|
||||
self._process.terminate()
|
||||
self._process.wait()
|
||||
|
||||
|
||||
def upload_once(base: str, token: str, chat_id: str, content: bytes, content_type: str) -> dict:
|
||||
request = urllib.request.Request(
|
||||
f"{base}/api/v1/chats/{chat_id}/attachments?filename=experiment",
|
||||
data=content,
|
||||
method="POST",
|
||||
headers={"Authorization": "Bearer " + token, "Content-Type": content_type},
|
||||
)
|
||||
started = time.monotonic()
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=REQUEST_TIMEOUT_SEC) as response:
|
||||
body, status, instance = response.read(), response.status, response.headers.get("X-Instance-Id")
|
||||
except urllib.error.HTTPError as error:
|
||||
body, status, instance = error.read(), error.code, error.headers.get("X-Instance-Id")
|
||||
except OSError as error:
|
||||
return {"status": None, "error": type(error).__name__, "seconds": time.monotonic() - started}
|
||||
result = {"status": status, "instance": instance, "seconds": time.monotonic() - started}
|
||||
if status == 201:
|
||||
result["id"] = json.loads(body)["id"]
|
||||
return result
|
||||
|
||||
|
||||
def percentile(values: list[float], share: float) -> float:
|
||||
ordered = sorted(values)
|
||||
return ordered[min(len(ordered) - 1, round(share * (len(ordered) - 1)))]
|
||||
|
||||
|
||||
def run_round(client: Client, actor: dict, chat: dict, profile: str, content: bytes,
|
||||
content_type: str, concurrency: int, restart: bool) -> dict:
|
||||
if restart:
|
||||
restart_api(client.base)
|
||||
containers = api_containers()
|
||||
# Прогрев: первый запрос каждой реплики открывает пулы БД/S3
|
||||
warmup = png_noise(4, 4)
|
||||
for _ in range(2 * len(containers)):
|
||||
upload_once(client.base, actor["token"], chat["id"], warmup, "image/png")
|
||||
before = {container_name(c): process_status(c) for c in containers}
|
||||
samplers = [Sampler(c) for c in containers]
|
||||
for sampler in samplers:
|
||||
sampler.start()
|
||||
time.sleep(1)
|
||||
|
||||
barrier = threading.Barrier(concurrency)
|
||||
results: list[dict] = [{} for _ in range(concurrency)]
|
||||
|
||||
def worker(index: int) -> None:
|
||||
barrier.wait()
|
||||
results[index] = upload_once(client.base, actor["token"], chat["id"], content, content_type)
|
||||
|
||||
started = time.monotonic()
|
||||
threads = [threading.Thread(target=worker, args=(i,)) for i in range(concurrency)]
|
||||
for thread in threads:
|
||||
thread.start()
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
wall = time.monotonic() - started
|
||||
time.sleep(1)
|
||||
for sampler in samplers:
|
||||
sampler.stop()
|
||||
after = {container_name(c): process_status(c) for c in containers}
|
||||
|
||||
ok = [r for r in results if r.get("status") == 201]
|
||||
sample = ok[0]["id"] if ok else None
|
||||
checksum_ok = None
|
||||
if sample:
|
||||
downloaded = client.call("GET", f"/api/v1/attachments/{sample}/content", actor=actor)["bytes"]
|
||||
checksum_ok = hashlib.sha256(downloaded).digest() == hashlib.sha256(content).digest()
|
||||
seconds = [r["seconds"] for r in ok]
|
||||
mib = 1024 * 1024
|
||||
replicas = {}
|
||||
for sampler in samplers:
|
||||
name = container_name(sampler.container)
|
||||
replicas[name] = {
|
||||
"uploads_served": sum(1 for r in ok if r.get("instance") == after[name].get("instance")),
|
||||
"rss_before_mib": round(before[name]["VmRSS"] / mib, 1),
|
||||
"rss_peak_process_vmhwm_mib": round(after[name]["VmHWM"] / mib, 1),
|
||||
"rss_peak_sampled_mib": round(sampler.rss_max / mib, 1),
|
||||
"cgroup_peak_sampled_mib": round(sampler.cgroup_max / mib, 1),
|
||||
"samples": sampler.samples,
|
||||
}
|
||||
by_instance: dict[str, int] = {}
|
||||
for r in ok:
|
||||
by_instance[r["instance"]] = by_instance.get(r["instance"], 0) + 1
|
||||
return {
|
||||
"profile": profile,
|
||||
"file_bytes": len(content),
|
||||
"concurrency": concurrency,
|
||||
"replicas_restarted_before": restart,
|
||||
"status_counts": {str(s): sum(1 for r in results if r.get("status") == s)
|
||||
for s in sorted({r.get("status") for r in results}, key=str)},
|
||||
"uploads_by_instance": by_instance,
|
||||
"wall_seconds": round(wall, 2),
|
||||
"latency_seconds": {
|
||||
"p50": round(percentile(seconds, 0.5), 3),
|
||||
"p95": round(percentile(seconds, 0.95), 3),
|
||||
"max": round(max(seconds), 3),
|
||||
} if seconds else None,
|
||||
"throughput_mib_per_second": round(len(ok) * len(content) / mib / wall, 1),
|
||||
"download_sha256_matches": checksum_ok,
|
||||
"replicas": replicas,
|
||||
}
|
||||
|
||||
|
||||
def environment() -> dict:
|
||||
info = json.loads(subprocess.run(
|
||||
["docker", "info", "--format", "{{json .}}"], capture_output=True, text=True, check=True
|
||||
).stdout)
|
||||
settings = {}
|
||||
for line in (ROOT / ".env").read_text().splitlines():
|
||||
key = line.split("=", 1)[0]
|
||||
if key in {"IMAGE_INSPECT_WORKERS", "UPLOAD_SPOOL_MEMORY_BYTES", "MAX_UPLOAD_BYTES",
|
||||
"MAX_IMAGE_PIXELS", "API_REPLICAS", "S3_POOL_MAX_SIZE"}:
|
||||
settings[key] = line.split("=", 1)[1]
|
||||
return {
|
||||
"host": f"{platform.system()} {platform.machine()}",
|
||||
"docker": info.get("ServerVersion"),
|
||||
"docker_vm_cpus": info.get("NCPU"),
|
||||
"docker_vm_memory_gib": round(info.get("MemTotal", 0) / 2**30, 1),
|
||||
"api_limits": "cpus 1.0, memory 512M per replica (compose.yaml)",
|
||||
"s3": "chrislusf/seaweedfs:4.48",
|
||||
"settings": settings,
|
||||
}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||||
parser.add_argument("--base-url", default=None)
|
||||
parser.add_argument("--output", default="evidence/experiment-uploads.json")
|
||||
parser.add_argument("--concurrency", default="10,20")
|
||||
parser.add_argument("--profiles", default="png,jpeg")
|
||||
parser.add_argument("--no-restart", action="store_true")
|
||||
args = parser.parse_args()
|
||||
|
||||
client = Client(args.base_url)
|
||||
alice, _, _, chat = client.bootstrap()
|
||||
payloads = {}
|
||||
if "png" in args.profiles:
|
||||
payloads["png"] = (png_noise(1750, 1750), "image/png")
|
||||
if "jpeg" in args.profiles:
|
||||
try:
|
||||
payloads["jpeg"] = (jpeg_worst_case(), "image/jpeg")
|
||||
except ImportError:
|
||||
print("jpeg profile skipped: Pillow is not installed (use poetry run)")
|
||||
report = {"environment": environment(), "rounds": []}
|
||||
for profile, (content, content_type) in payloads.items():
|
||||
for concurrency in (int(x) for x in args.concurrency.split(",")):
|
||||
result = run_round(client, alice, chat, profile, content, content_type,
|
||||
concurrency, not args.no_restart)
|
||||
report["rounds"].append(result)
|
||||
print(json.dumps(result, ensure_ascii=False))
|
||||
output = ROOT / args.output
|
||||
output.parent.mkdir(parents=True, exist_ok=True)
|
||||
output.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
|
||||
print("saved:", args.output)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,4 @@
|
||||
from .api import app as api_endpoints
|
||||
from .api import health_router as health_endpoints
|
||||
|
||||
__all__ = ["api_endpoints", "health_endpoints"]
|
||||
@@ -0,0 +1,10 @@
|
||||
from fastapi import APIRouter
|
||||
|
||||
from .health import health_router
|
||||
from .routers import app as v1_endpoints
|
||||
|
||||
app = APIRouter(prefix="/api")
|
||||
|
||||
app.include_router(v1_endpoints)
|
||||
|
||||
__all__ = ["app", "health_router"]
|
||||
@@ -0,0 +1,4 @@
|
||||
from .auth import get_current_user
|
||||
from .security import basic_credentials, bearer_token
|
||||
|
||||
__all__ = ["get_current_user", "basic_credentials", "bearer_token"]
|
||||
@@ -0,0 +1,15 @@
|
||||
from fastapi import Depends
|
||||
|
||||
from domain import UserSchema
|
||||
from infrastructure.dependencies import ServiceCreator
|
||||
from infrastructure.services import AuthService
|
||||
|
||||
from .security import bearer_token
|
||||
|
||||
|
||||
async def get_current_user(
|
||||
token: str | None = Depends(bearer_token),
|
||||
service: AuthService = Depends(ServiceCreator.get_auth_service),
|
||||
) -> UserSchema:
|
||||
"""Владелец действующей Bearer-сессии; X-User-Id не учитывается; иначе 401"""
|
||||
return await service.authenticate(token)
|
||||
@@ -0,0 +1,52 @@
|
||||
import base64
|
||||
import binascii
|
||||
|
||||
from fastapi import Depends
|
||||
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
|
||||
from fastapi.security.http import HTTPBase
|
||||
|
||||
from domain import BasicCredentialsSchema
|
||||
from domain.errors import InvalidCredentialsError
|
||||
|
||||
BASIC_SCHEME = "basic"
|
||||
|
||||
basic_scheme = HTTPBase(
|
||||
scheme=BASIC_SCHEME,
|
||||
scheme_name="basicAuth",
|
||||
description="Только для POST /auth/sessions",
|
||||
auto_error=False,
|
||||
)
|
||||
|
||||
bearer_scheme = HTTPBearer(
|
||||
scheme_name="bearerAuth",
|
||||
bearerFormat="opaque session token",
|
||||
auto_error=False,
|
||||
)
|
||||
|
||||
|
||||
async def basic_credentials(
|
||||
authorization: HTTPAuthorizationCredentials | None = Depends(basic_scheme),
|
||||
) -> BasicCredentialsSchema:
|
||||
"""
|
||||
Authorization: Basic base64(username:password)
|
||||
|
||||
username — до первого двоеточия, остальное — пароль
|
||||
Любая ошибка формата — тот же 401, что и неверный пароль.
|
||||
"""
|
||||
if authorization is None or authorization.scheme.lower() != BASIC_SCHEME:
|
||||
raise InvalidCredentialsError()
|
||||
try:
|
||||
decoded = base64.b64decode(authorization.credentials, validate=True)
|
||||
username, separator, password = decoded.decode("utf-8").partition(":")
|
||||
except (binascii.Error, UnicodeDecodeError):
|
||||
raise InvalidCredentialsError() from None
|
||||
if not separator or not username.isascii():
|
||||
raise InvalidCredentialsError()
|
||||
return BasicCredentialsSchema(username=username, password=password)
|
||||
|
||||
|
||||
async def bearer_token(
|
||||
authorization: HTTPAuthorizationCredentials | None = Depends(bearer_scheme),
|
||||
) -> str | None:
|
||||
"""Токен из Authorization: Bearer; другие схемы (Basic) — как отсутствие"""
|
||||
return authorization.credentials if authorization is not None else None
|
||||
@@ -0,0 +1,3 @@
|
||||
from .exceptions import register_exception_handlers
|
||||
|
||||
__all__ = ["register_exception_handlers"]
|
||||
@@ -0,0 +1,61 @@
|
||||
from http import HTTPStatus
|
||||
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
|
||||
from application.api.utils import error_response, get_request_id
|
||||
from domain.errors import AppError, ErrorCode, InvalidRequestError, NotFoundError
|
||||
|
||||
|
||||
async def app_error_handler(request: Request, error: Exception) -> JSONResponse:
|
||||
"""Доменные ошибки сервисов и репозиториев"""
|
||||
assert isinstance(error, AppError)
|
||||
return error_response(
|
||||
get_request_id(request),
|
||||
error.status_code,
|
||||
error.code,
|
||||
error.message,
|
||||
error.headers,
|
||||
)
|
||||
|
||||
|
||||
async def validation_error_handler(request: Request, error: Exception) -> JSONResponse:
|
||||
"""Malformed JSON, лишние поля, неверные типы, uuid и limit — 400"""
|
||||
assert isinstance(error, RequestValidationError)
|
||||
return error_response(
|
||||
get_request_id(request),
|
||||
InvalidRequestError.status_code,
|
||||
InvalidRequestError.code,
|
||||
_describe_validation_error(error),
|
||||
)
|
||||
|
||||
|
||||
async def http_error_handler(request: Request, error: Exception) -> JSONResponse:
|
||||
"""Ошибки маршрутизации неизвестный путь, неподдерживаемый метод"""
|
||||
assert isinstance(error, StarletteHTTPException)
|
||||
if error.status_code == HTTPStatus.NOT_FOUND:
|
||||
code, message = NotFoundError.code, NotFoundError.default_message
|
||||
elif error.status_code >= HTTPStatus.INTERNAL_SERVER_ERROR:
|
||||
code, message = AppError.code, AppError.default_message
|
||||
else:
|
||||
code, message = ErrorCode.INVALID_REQUEST, HTTPStatus(error.status_code).phrase
|
||||
return error_response(
|
||||
get_request_id(request), error.status_code, code, message, error.headers
|
||||
)
|
||||
|
||||
|
||||
def _describe_validation_error(error: RequestValidationError) -> str:
|
||||
"""Безопасное описание: только тип и путь поля, без присланного значения"""
|
||||
first = error.errors()[0]
|
||||
if first.get("type") == "json_invalid":
|
||||
return "Некорректный JSON в теле запроса"
|
||||
location = ".".join(str(part) for part in first.get("loc", ()))
|
||||
return f"Некорректное значение: {location}"
|
||||
|
||||
|
||||
def register_exception_handlers(app: FastAPI) -> None:
|
||||
app.add_exception_handler(AppError, app_error_handler)
|
||||
app.add_exception_handler(RequestValidationError, validation_error_handler)
|
||||
app.add_exception_handler(StarletteHTTPException, http_error_handler)
|
||||
@@ -0,0 +1,3 @@
|
||||
from .endpoints import health_router
|
||||
|
||||
__all__ = ["health_router"]
|
||||
@@ -0,0 +1,49 @@
|
||||
from fastapi import APIRouter, Depends, Request, status
|
||||
|
||||
from domain import HealthSchema
|
||||
from domain.errors import UnavailableError
|
||||
from infrastructure.dependencies import (
|
||||
DatabasePoolManager,
|
||||
ObjectStorageManager,
|
||||
get_database,
|
||||
get_storage,
|
||||
)
|
||||
|
||||
health_router = APIRouter(prefix="/health", tags=["Health"])
|
||||
|
||||
|
||||
@health_router.get(
|
||||
"/live",
|
||||
status_code=status.HTTP_200_OK,
|
||||
response_model=HealthSchema,
|
||||
)
|
||||
async def liveness() -> HealthSchema:
|
||||
"""Процесс жив и обрабатывает хттп"""
|
||||
return HealthSchema()
|
||||
|
||||
|
||||
@health_router.get(
|
||||
"/ready",
|
||||
status_code=status.HTTP_200_OK,
|
||||
response_model=HealthSchema,
|
||||
)
|
||||
async def readiness(
|
||||
request: Request,
|
||||
database: DatabasePoolManager = Depends(get_database),
|
||||
storage: ObjectStorageManager = Depends(get_storage),
|
||||
) -> HealthSchema:
|
||||
"""
|
||||
Приложение не завершается, PostgreSQL и S3 отвечают: с lab4 загрузка
|
||||
и скачивание вложений входят в обязательный синхронный путь.
|
||||
|
||||
Valkey не критичен: без него сессии читаются из PostgreSQL. Без S3
|
||||
недоступны только вложения — nginx не исключает реплику по readiness,
|
||||
поэтому сообщения продолжают работать, а реплика честно сообщает 503.
|
||||
"""
|
||||
if not getattr(request.app.state, "is_ready", False):
|
||||
raise UnavailableError()
|
||||
if not await database.check():
|
||||
raise UnavailableError("бд недоступна")
|
||||
if not await storage.check():
|
||||
raise UnavailableError("хранилище файлов недоступно")
|
||||
return HealthSchema()
|
||||
@@ -0,0 +1,3 @@
|
||||
from .request_context import RequestContextMiddleware
|
||||
|
||||
__all__ = ["RequestContextMiddleware"]
|
||||
@@ -0,0 +1,71 @@
|
||||
import re
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from fastapi import Request, Response
|
||||
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
|
||||
|
||||
from application.api.utils import INSTANCE_ID_HEADER, REQUEST_ID_HEADER, error_response
|
||||
from config import INSTANCE_ID, LOGGER
|
||||
from domain.errors import AppError
|
||||
|
||||
HEALTH_PATH_PREFIX = "/health/"
|
||||
|
||||
INCOMING_REQUEST_ID = re.compile(r"^[0-9a-f]{32}$")
|
||||
|
||||
|
||||
class RequestContextMiddleware(BaseHTTPMiddleware):
|
||||
"""
|
||||
X-Request-Id и X-Instance-Id в каждом ответе, журнал запросов и защита
|
||||
от необработанных ошибок.
|
||||
|
||||
X-Request-Id берётся у балансировщика (nginx выставляет $request_id),
|
||||
поэтому одна строка access-лога LB и журнал реплики связаны одним ID.
|
||||
В лог попадают метод, путь, статус и длительность — без тел запросов,
|
||||
query-параметров и текста сообщений.
|
||||
"""
|
||||
|
||||
async def dispatch(
|
||||
self, request: Request, call_next: RequestResponseEndpoint
|
||||
) -> Response:
|
||||
request_id = self._request_id(request)
|
||||
request.state.request_id = request_id
|
||||
started = time.perf_counter()
|
||||
try:
|
||||
response = await call_next(request)
|
||||
except Exception:
|
||||
LOGGER.exception(f"Необработанная ошибка | request_id={request_id}")
|
||||
error = AppError()
|
||||
response = error_response(
|
||||
request_id, error.status_code, error.code, error.message
|
||||
)
|
||||
response.headers[REQUEST_ID_HEADER] = request_id
|
||||
response.headers[INSTANCE_ID_HEADER] = INSTANCE_ID
|
||||
if getattr(request.app.state, "is_draining", False):
|
||||
response.headers["Connection"] = "close"
|
||||
self._log_request(request, response, request_id, started)
|
||||
return response
|
||||
|
||||
@staticmethod
|
||||
def _request_id(request: Request) -> str:
|
||||
incoming = request.headers.get(REQUEST_ID_HEADER, "")
|
||||
if INCOMING_REQUEST_ID.fullmatch(incoming):
|
||||
return incoming
|
||||
return uuid.uuid4().hex
|
||||
|
||||
@staticmethod
|
||||
def _log_request(
|
||||
request: Request, response: Response, request_id: str, started: float
|
||||
) -> None:
|
||||
duration_ms = (time.perf_counter() - started) * 1000
|
||||
if response.status_code >= 500:
|
||||
level = "ERROR"
|
||||
elif request.url.path.startswith(HEALTH_PATH_PREFIX):
|
||||
level = "DEBUG"
|
||||
else:
|
||||
level = "INFO"
|
||||
LOGGER.log(
|
||||
level,
|
||||
f"{request.method} {request.url.path} -> {response.status_code} "
|
||||
f"| {duration_ms:.1f} ms | request_id={request_id}",
|
||||
)
|
||||
@@ -0,0 +1,17 @@
|
||||
from fastapi import APIRouter
|
||||
|
||||
from .attachments import attachments_router
|
||||
from .auth import auth_router
|
||||
from .chats import chats_router
|
||||
from .messages import messages_router
|
||||
from .users import users_router
|
||||
|
||||
app = APIRouter(prefix="/v1")
|
||||
|
||||
app.include_router(users_router)
|
||||
app.include_router(auth_router)
|
||||
app.include_router(chats_router)
|
||||
app.include_router(messages_router)
|
||||
app.include_router(attachments_router)
|
||||
|
||||
__all__ = ["app"]
|
||||
@@ -0,0 +1,3 @@
|
||||
from .endpoints import attachments_router
|
||||
|
||||
__all__ = ["attachments_router"]
|
||||
@@ -0,0 +1,100 @@
|
||||
from typing import Annotated
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Depends, Header, Query, Request, status
|
||||
from fastapi.responses import StreamingResponse
|
||||
from starlette.background import BackgroundTask
|
||||
|
||||
from application.api.dependencies import get_current_user
|
||||
from application.api.utils import content_disposition, request_chunks
|
||||
from domain import (
|
||||
AttachmentContentType,
|
||||
AttachmentFilename,
|
||||
AttachmentSchema,
|
||||
AttachmentVariant,
|
||||
UserSchema,
|
||||
)
|
||||
from infrastructure.dependencies import ServiceCreator
|
||||
from infrastructure.services import AttachmentService
|
||||
|
||||
attachments_router = APIRouter(tags=["Attachments"])
|
||||
|
||||
IMAGE_BODY = {
|
||||
content_type: {"schema": {"type": "string", "format": "binary"}}
|
||||
for content_type in AttachmentContentType
|
||||
}
|
||||
|
||||
|
||||
@attachments_router.post(
|
||||
"/chats/{chat_id}/attachments",
|
||||
status_code=status.HTTP_201_CREATED,
|
||||
response_model=AttachmentSchema,
|
||||
openapi_extra={"requestBody": {"required": True, "content": IMAGE_BODY}},
|
||||
)
|
||||
async def upload_attachment(
|
||||
chat_id: UUID,
|
||||
filename: Annotated[AttachmentFilename, Query()],
|
||||
request: Request,
|
||||
content_type: Annotated[str | None, Header()] = None,
|
||||
content_length: Annotated[int | None, Header(ge=0)] = None,
|
||||
current_user: UserSchema = Depends(get_current_user),
|
||||
service: AttachmentService = Depends(ServiceCreator.get_attachment_service),
|
||||
) -> AttachmentSchema:
|
||||
"""
|
||||
Сырые байты одного PNG/JPEG, не multipart. 201 ready — только после
|
||||
сохранения оригинала в S3 и метаданных в PostgreSQL.
|
||||
"""
|
||||
return await service.upload(
|
||||
current_user,
|
||||
chat_id,
|
||||
filename,
|
||||
content_type,
|
||||
content_length,
|
||||
request_chunks(request),
|
||||
)
|
||||
|
||||
|
||||
@attachments_router.get(
|
||||
"/attachments/{attachment_id}",
|
||||
status_code=status.HTTP_200_OK,
|
||||
response_model=AttachmentSchema,
|
||||
)
|
||||
async def get_attachment(
|
||||
attachment_id: UUID,
|
||||
current_user: UserSchema = Depends(get_current_user),
|
||||
service: AttachmentService = Depends(ServiceCreator.get_attachment_service),
|
||||
) -> AttachmentSchema:
|
||||
"""Метаданные доступны только участникам чата вложения; остальным — 404"""
|
||||
return await service.get_attachment(current_user, attachment_id)
|
||||
|
||||
|
||||
@attachments_router.get(
|
||||
"/attachments/{attachment_id}/content",
|
||||
status_code=status.HTTP_200_OK,
|
||||
response_class=StreamingResponse,
|
||||
responses={200: {"content": IMAGE_BODY}},
|
||||
)
|
||||
async def download_attachment(
|
||||
attachment_id: UUID,
|
||||
variant: Annotated[AttachmentVariant, Query()] = AttachmentVariant.ORIGINAL,
|
||||
current_user: UserSchema = Depends(get_current_user),
|
||||
service: AttachmentService = Depends(ServiceCreator.get_attachment_service),
|
||||
) -> StreamingResponse:
|
||||
"""
|
||||
Байты через API, без redirect на S3: доступ проверяет приложение.
|
||||
Ответ идёт потоком из S3, файл целиком в памяти реплики не собирается.
|
||||
"""
|
||||
attachment, content = await service.open_content(
|
||||
current_user, attachment_id, variant
|
||||
)
|
||||
return StreamingResponse(
|
||||
content.iter_chunks(),
|
||||
media_type=attachment.content_type,
|
||||
headers={
|
||||
"Content-Length": str(content.content_length),
|
||||
"Content-Disposition": content_disposition(attachment.filename),
|
||||
"X-Content-Type-Options": "nosniff",
|
||||
"Cache-Control": "private, no-store",
|
||||
},
|
||||
background=BackgroundTask(content.close),
|
||||
)
|
||||
@@ -0,0 +1,3 @@
|
||||
from .endpoints import auth_router
|
||||
|
||||
__all__ = ["auth_router"]
|
||||
@@ -0,0 +1,35 @@
|
||||
from fastapi import APIRouter, Depends, Response, status
|
||||
|
||||
from application.api.dependencies import basic_credentials, bearer_token
|
||||
from domain import BasicCredentialsSchema, SessionSchema
|
||||
from infrastructure.dependencies import ServiceCreator
|
||||
from infrastructure.services import AuthService
|
||||
|
||||
auth_router = APIRouter(prefix="/auth/sessions", tags=["Auth"])
|
||||
|
||||
|
||||
@auth_router.post(
|
||||
"",
|
||||
status_code=status.HTTP_201_CREATED,
|
||||
response_model=SessionSchema,
|
||||
)
|
||||
async def create_session(
|
||||
credentials: BasicCredentialsSchema = Depends(basic_credentials),
|
||||
service: AuthService = Depends(ServiceCreator.get_auth_service),
|
||||
) -> SessionSchema:
|
||||
"""Вход по Basic, без JSON body; возвращает Bearer-токен"""
|
||||
return await service.login(credentials)
|
||||
|
||||
|
||||
@auth_router.delete(
|
||||
"/current",
|
||||
status_code=status.HTTP_204_NO_CONTENT,
|
||||
response_class=Response,
|
||||
)
|
||||
async def revoke_session(
|
||||
token: str | None = Depends(bearer_token),
|
||||
service: AuthService = Depends(ServiceCreator.get_auth_service),
|
||||
) -> Response:
|
||||
"""Logout: текущий токен перестаёт действовать; повтор — 401"""
|
||||
await service.logout(token)
|
||||
return Response(status_code=status.HTTP_204_NO_CONTENT)
|
||||
@@ -0,0 +1,3 @@
|
||||
from .endpoints import chats_router
|
||||
|
||||
__all__ = ["chats_router"]
|
||||
@@ -0,0 +1,58 @@
|
||||
from typing import Annotated
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Body, Depends, Query, status
|
||||
|
||||
from application.api.dependencies import get_current_user
|
||||
from domain import (
|
||||
ChatPageSchema,
|
||||
ChatSchema,
|
||||
CreateChatSchema,
|
||||
UserSchema,
|
||||
)
|
||||
from infrastructure.dependencies import ServiceCreator
|
||||
from infrastructure.services import ChatService
|
||||
|
||||
chats_router = APIRouter(prefix="/chats", tags=["Chats"])
|
||||
|
||||
|
||||
@chats_router.post(
|
||||
"",
|
||||
status_code=status.HTTP_201_CREATED,
|
||||
response_model=ChatSchema,
|
||||
)
|
||||
async def create_chat(
|
||||
body: Annotated[CreateChatSchema, Body(...)],
|
||||
current_user: UserSchema = Depends(get_current_user),
|
||||
service: ChatService = Depends(ServiceCreator.get_chat_service),
|
||||
) -> ChatSchema:
|
||||
"""Вызывающий должен входить в member_ids"""
|
||||
return await service.create_chat(current_user, body)
|
||||
|
||||
|
||||
@chats_router.get(
|
||||
"",
|
||||
status_code=status.HTTP_200_OK,
|
||||
response_model=ChatPageSchema,
|
||||
)
|
||||
async def list_chats(
|
||||
limit: Annotated[int, Query(ge=1, le=100)] = 50,
|
||||
cursor: Annotated[str | None, Query(min_length=1)] = None,
|
||||
current_user: UserSchema = Depends(get_current_user),
|
||||
service: ChatService = Depends(ServiceCreator.get_chat_service),
|
||||
) -> ChatPageSchema:
|
||||
"""Чаты текущего пользователя по (created_at, id) по возрастанию"""
|
||||
return await service.list_chats(current_user, limit, cursor)
|
||||
|
||||
|
||||
@chats_router.get(
|
||||
"/{chat_id}",
|
||||
status_code=status.HTTP_200_OK,
|
||||
response_model=ChatSchema,
|
||||
)
|
||||
async def get_chat(
|
||||
chat_id: UUID,
|
||||
current_user: UserSchema = Depends(get_current_user),
|
||||
service: ChatService = Depends(ServiceCreator.get_chat_service),
|
||||
) -> ChatSchema:
|
||||
return await service.get_chat(current_user, chat_id)
|
||||
@@ -0,0 +1,3 @@
|
||||
from .endpoints import messages_router
|
||||
|
||||
__all__ = ["messages_router"]
|
||||
@@ -0,0 +1,63 @@
|
||||
from typing import Annotated
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Body, Depends, Header, Query, status
|
||||
|
||||
from application.api.dependencies import get_current_user
|
||||
from domain import (
|
||||
IDEMPOTENCY_KEY_MAX_LENGTH,
|
||||
IDEMPOTENCY_KEY_PATTERN,
|
||||
CreateMessageSchema,
|
||||
MessagePageSchema,
|
||||
MessageSchema,
|
||||
UserSchema,
|
||||
)
|
||||
from infrastructure.dependencies import ServiceCreator
|
||||
from infrastructure.services import MessageService
|
||||
|
||||
messages_router = APIRouter(
|
||||
prefix="/chats/{chat_id}/messages", tags=["Messages"]
|
||||
)
|
||||
|
||||
|
||||
@messages_router.post(
|
||||
"",
|
||||
status_code=status.HTTP_201_CREATED,
|
||||
response_model=MessageSchema,
|
||||
)
|
||||
async def send_message(
|
||||
chat_id: UUID,
|
||||
body: Annotated[CreateMessageSchema, Body(...)],
|
||||
idempotency_key: Annotated[
|
||||
str,
|
||||
Header(
|
||||
alias="Idempotency-Key",
|
||||
min_length=1,
|
||||
max_length=IDEMPOTENCY_KEY_MAX_LENGTH,
|
||||
pattern=IDEMPOTENCY_KEY_PATTERN,
|
||||
),
|
||||
],
|
||||
current_user: UserSchema = Depends(get_current_user),
|
||||
service: MessageService = Depends(ServiceCreator.get_message_service),
|
||||
) -> MessageSchema:
|
||||
"""
|
||||
Idempotency-Key обязателен: повтор того же тела возвращает тот же 201
|
||||
и то же сообщение, другое тело с тем же ключом — 409. Нет/неверный ключ — 400.
|
||||
"""
|
||||
return await service.send_message(current_user, chat_id, body, idempotency_key)
|
||||
|
||||
|
||||
@messages_router.get(
|
||||
"",
|
||||
status_code=status.HTTP_200_OK,
|
||||
response_model=MessagePageSchema,
|
||||
)
|
||||
async def list_messages(
|
||||
chat_id: UUID,
|
||||
limit: Annotated[int, Query(ge=1, le=100)] = 50,
|
||||
cursor: Annotated[str | None, Query(min_length=1)] = None,
|
||||
current_user: UserSchema = Depends(get_current_user),
|
||||
service: MessageService = Depends(ServiceCreator.get_message_service),
|
||||
) -> MessagePageSchema:
|
||||
"""История чата: keyset cursor по (created_at, id) по возрастанию"""
|
||||
return await service.list_messages(current_user, chat_id, limit, cursor)
|
||||
@@ -0,0 +1,3 @@
|
||||
from .endpoints import users_router
|
||||
|
||||
__all__ = ["users_router"]
|
||||
@@ -0,0 +1,33 @@
|
||||
from typing import Annotated
|
||||
|
||||
from fastapi import APIRouter, Body, Depends, status
|
||||
|
||||
from application.api.dependencies import get_current_user
|
||||
from domain import CreateUserSchema, UserSchema
|
||||
from infrastructure.dependencies import ServiceCreator
|
||||
from infrastructure.services import UserService
|
||||
|
||||
users_router = APIRouter(prefix="/users", tags=["Users"])
|
||||
|
||||
|
||||
@users_router.post(
|
||||
"",
|
||||
status_code=status.HTTP_201_CREATED,
|
||||
response_model=UserSchema,
|
||||
openapi_extra={"security": []},
|
||||
)
|
||||
async def register_user(
|
||||
body: Annotated[CreateUserSchema, Body(...)],
|
||||
service: UserService = Depends(ServiceCreator.get_user_service),
|
||||
) -> UserSchema:
|
||||
"""Публичная регистрация; username уникален"""
|
||||
return await service.register(body)
|
||||
|
||||
|
||||
@users_router.get(
|
||||
"/me",
|
||||
status_code=status.HTTP_200_OK,
|
||||
response_model=UserSchema,
|
||||
)
|
||||
async def get_me(current_user: UserSchema = Depends(get_current_user)) -> UserSchema:
|
||||
return current_user
|
||||
@@ -0,0 +1,16 @@
|
||||
from .errors import (
|
||||
INSTANCE_ID_HEADER,
|
||||
REQUEST_ID_HEADER,
|
||||
error_response,
|
||||
get_request_id,
|
||||
)
|
||||
from .streams import content_disposition, request_chunks
|
||||
|
||||
__all__ = [
|
||||
"REQUEST_ID_HEADER",
|
||||
"INSTANCE_ID_HEADER",
|
||||
"error_response",
|
||||
"get_request_id",
|
||||
"request_chunks",
|
||||
"content_disposition",
|
||||
]
|
||||
@@ -0,0 +1,33 @@
|
||||
from collections.abc import Mapping
|
||||
|
||||
from fastapi import Request
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
from domain.errors import ErrorBodySchema, ErrorCode, ErrorSchema
|
||||
|
||||
REQUEST_ID_HEADER = "X-Request-Id"
|
||||
INSTANCE_ID_HEADER = "X-Instance-Id"
|
||||
|
||||
|
||||
def get_request_id(request: Request) -> str:
|
||||
"""ID запроса, назначенный RequestContextMiddleware"""
|
||||
request_id: str = request.state.request_id
|
||||
return request_id
|
||||
|
||||
|
||||
def error_response(
|
||||
request_id: str,
|
||||
status_code: int,
|
||||
code: ErrorCode,
|
||||
message: str,
|
||||
headers: Mapping[str, str] | None = None,
|
||||
) -> JSONResponse:
|
||||
"""Ответ в едином формате ошибки контракта"""
|
||||
body = ErrorSchema(
|
||||
error=ErrorBodySchema(code=code, message=message, request_id=request_id)
|
||||
)
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content=body.model_dump(mode="json"),
|
||||
headers={**(headers or {}), REQUEST_ID_HEADER: request_id},
|
||||
)
|
||||
@@ -0,0 +1,28 @@
|
||||
from collections.abc import AsyncIterator
|
||||
from urllib.parse import quote
|
||||
|
||||
from fastapi import Request
|
||||
from starlette.requests import ClientDisconnect
|
||||
|
||||
from domain.errors import InvalidRequestError
|
||||
|
||||
|
||||
async def request_chunks(request: Request) -> AsyncIterator[bytes]:
|
||||
"""
|
||||
Тело запроса потоком, без буферизации целиком. Обрыв соединения клиентом
|
||||
— доменная ошибка, а не необработанное исключение (500 в журнале).
|
||||
"""
|
||||
try:
|
||||
async for chunk in request.stream():
|
||||
if chunk:
|
||||
yield chunk
|
||||
except ClientDisconnect:
|
||||
raise InvalidRequestError("Загрузка прервана клиентом") from None
|
||||
|
||||
|
||||
def content_disposition(filename: str) -> str:
|
||||
"""
|
||||
inline с именем по RFC 6266/5987: имя целиком percent-encoded, поэтому
|
||||
кавычки, ; и переводы строк не могут разорвать заголовок.
|
||||
"""
|
||||
return f"inline; filename*=UTF-8''{quote(filename, safe='')}"
|
||||
@@ -0,0 +1,107 @@
|
||||
from .log_config import LOGGER
|
||||
from .settings import (
|
||||
APP_ENV,
|
||||
APP_HOST,
|
||||
APP_KEEPALIVE_TIMEOUT_SEC,
|
||||
APP_PORT,
|
||||
APP_REVISION,
|
||||
ATTACHMENT_PENDING_GRACE_SEC,
|
||||
ATTACHMENT_STORE_TIMEOUT_SEC,
|
||||
DB_COMMAND_TIMEOUT_SEC,
|
||||
DB_CONNECT_TIMEOUT_SEC,
|
||||
DB_HOST,
|
||||
DB_NAME,
|
||||
DB_PASS,
|
||||
DB_POOL_MAX_SIZE,
|
||||
DB_POOL_MIN_SIZE,
|
||||
DB_PORT,
|
||||
DB_STARTUP_TIMEOUT_SEC,
|
||||
DB_USER,
|
||||
IDEMPOTENCY_TTL_SECONDS,
|
||||
IMAGE_INSPECT_WORKERS,
|
||||
INSTANCE_ID,
|
||||
INSTANCE_ID_FILE,
|
||||
JANITOR_HEARTBEAT_FILE,
|
||||
JANITOR_INTERVAL_SEC,
|
||||
LOG_LEVEL,
|
||||
MAX_IMAGE_PIXELS,
|
||||
MAX_UPLOAD_BYTES,
|
||||
PASSWORD_HASH_WORKERS,
|
||||
S3_ACCESS_KEY_ID_FILE,
|
||||
S3_ADMIN_ACCESS_KEY_ID_FILE,
|
||||
S3_ADMIN_SECRET_ACCESS_KEY_FILE,
|
||||
S3_BUCKET,
|
||||
S3_CONNECT_TIMEOUT_SEC,
|
||||
S3_ENDPOINT,
|
||||
S3_MAX_ATTEMPTS,
|
||||
S3_POOL_MAX_SIZE,
|
||||
S3_READ_TIMEOUT_SEC,
|
||||
S3_REGION,
|
||||
S3_SECRET_ACCESS_KEY_FILE,
|
||||
S3_STARTUP_TIMEOUT_SEC,
|
||||
SESSION_CACHE_TTL_SECONDS,
|
||||
SESSION_TTL_SECONDS,
|
||||
SHUTDOWN_DRAIN_SEC,
|
||||
SHUTDOWN_TIMEOUT_SEC,
|
||||
UPLOAD_SPOOL_MEMORY_BYTES,
|
||||
VALKEY_HOST,
|
||||
VALKEY_PASS,
|
||||
VALKEY_POOL_MAX_SIZE,
|
||||
VALKEY_PORT,
|
||||
VALKEY_RETRY_AFTER_SEC,
|
||||
VALKEY_TIMEOUT_SEC,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
"LOGGER",
|
||||
"APP_HOST",
|
||||
"APP_PORT",
|
||||
"APP_ENV",
|
||||
"APP_REVISION",
|
||||
"APP_KEEPALIVE_TIMEOUT_SEC",
|
||||
"LOG_LEVEL",
|
||||
"SHUTDOWN_TIMEOUT_SEC",
|
||||
"SHUTDOWN_DRAIN_SEC",
|
||||
"DB_USER",
|
||||
"DB_PASS",
|
||||
"DB_NAME",
|
||||
"DB_HOST",
|
||||
"DB_PORT",
|
||||
"DB_POOL_MIN_SIZE",
|
||||
"DB_POOL_MAX_SIZE",
|
||||
"DB_CONNECT_TIMEOUT_SEC",
|
||||
"DB_COMMAND_TIMEOUT_SEC",
|
||||
"DB_STARTUP_TIMEOUT_SEC",
|
||||
"VALKEY_HOST",
|
||||
"VALKEY_PORT",
|
||||
"VALKEY_PASS",
|
||||
"VALKEY_POOL_MAX_SIZE",
|
||||
"VALKEY_TIMEOUT_SEC",
|
||||
"VALKEY_RETRY_AFTER_SEC",
|
||||
"SESSION_TTL_SECONDS",
|
||||
"SESSION_CACHE_TTL_SECONDS",
|
||||
"PASSWORD_HASH_WORKERS",
|
||||
"IDEMPOTENCY_TTL_SECONDS",
|
||||
"S3_ENDPOINT",
|
||||
"S3_REGION",
|
||||
"S3_BUCKET",
|
||||
"S3_ACCESS_KEY_ID_FILE",
|
||||
"S3_SECRET_ACCESS_KEY_FILE",
|
||||
"S3_ADMIN_ACCESS_KEY_ID_FILE",
|
||||
"S3_ADMIN_SECRET_ACCESS_KEY_FILE",
|
||||
"S3_POOL_MAX_SIZE",
|
||||
"S3_CONNECT_TIMEOUT_SEC",
|
||||
"S3_READ_TIMEOUT_SEC",
|
||||
"S3_MAX_ATTEMPTS",
|
||||
"S3_STARTUP_TIMEOUT_SEC",
|
||||
"MAX_UPLOAD_BYTES",
|
||||
"MAX_IMAGE_PIXELS",
|
||||
"UPLOAD_SPOOL_MEMORY_BYTES",
|
||||
"IMAGE_INSPECT_WORKERS",
|
||||
"ATTACHMENT_STORE_TIMEOUT_SEC",
|
||||
"ATTACHMENT_PENDING_GRACE_SEC",
|
||||
"JANITOR_INTERVAL_SEC",
|
||||
"INSTANCE_ID",
|
||||
"INSTANCE_ID_FILE",
|
||||
"JANITOR_HEARTBEAT_FILE",
|
||||
]
|
||||
@@ -0,0 +1,12 @@
|
||||
"""Сборщик логов"""
|
||||
|
||||
import sys
|
||||
|
||||
from loguru import logger
|
||||
|
||||
from .settings import LOG_LEVEL
|
||||
|
||||
LOGGER = logger
|
||||
|
||||
LOGGER.remove()
|
||||
LOGGER.add(sys.stdout, level=LOG_LEVEL, diagnose=False)
|
||||
@@ -0,0 +1,76 @@
|
||||
import os
|
||||
import secrets
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
from envparse import Env
|
||||
|
||||
env = Env()
|
||||
|
||||
ENV_FILE = Path(os.getenv("ENV_FILE", ".env"))
|
||||
if ENV_FILE.is_file():
|
||||
env.read_envfile(path=str(ENV_FILE))
|
||||
|
||||
APP_HOST = env.str("APP_HOST")
|
||||
APP_PORT = env.int("APP_PORT")
|
||||
APP_ENV = env.str("APP_ENV")
|
||||
APP_REVISION = env.str("APP_REVISION", default="dev")
|
||||
# Больше keepalive_timeout балансировщика: idle-соединение закрывает LB, а не API
|
||||
APP_KEEPALIVE_TIMEOUT_SEC = env.int("APP_KEEPALIVE_TIMEOUT_SEC")
|
||||
|
||||
LOG_LEVEL = env.str("LOG_LEVEL")
|
||||
SHUTDOWN_TIMEOUT_SEC = env.int("SHUTDOWN_TIMEOUT_SEC")
|
||||
SHUTDOWN_DRAIN_SEC = env.float("SHUTDOWN_DRAIN_SEC")
|
||||
|
||||
DB_USER = env.str("DB_USER")
|
||||
DB_PASS = env.str("DB_PASS")
|
||||
DB_NAME = env.str("DB_NAME")
|
||||
DB_HOST = env.str("DB_HOST")
|
||||
DB_PORT = env.int("DB_PORT")
|
||||
DB_POOL_MIN_SIZE = env.int("DB_POOL_MIN_SIZE")
|
||||
DB_POOL_MAX_SIZE = env.int("DB_POOL_MAX_SIZE")
|
||||
DB_CONNECT_TIMEOUT_SEC = env.float("DB_CONNECT_TIMEOUT_SEC")
|
||||
DB_COMMAND_TIMEOUT_SEC = env.float("DB_COMMAND_TIMEOUT_SEC")
|
||||
DB_STARTUP_TIMEOUT_SEC = env.float("DB_STARTUP_TIMEOUT_SEC")
|
||||
|
||||
VALKEY_HOST = env.str("VALKEY_HOST")
|
||||
VALKEY_PORT = env.int("VALKEY_PORT")
|
||||
VALKEY_PASS = env.str("VALKEY_PASS")
|
||||
VALKEY_POOL_MAX_SIZE = env.int("VALKEY_POOL_MAX_SIZE")
|
||||
VALKEY_TIMEOUT_SEC = env.float("VALKEY_TIMEOUT_SEC")
|
||||
VALKEY_RETRY_AFTER_SEC = env.float("VALKEY_RETRY_AFTER_SEC")
|
||||
|
||||
SESSION_TTL_SECONDS = env.int("SESSION_TTL_SECONDS")
|
||||
SESSION_CACHE_TTL_SECONDS = env.int("SESSION_CACHE_TTL_SECONDS")
|
||||
PASSWORD_HASH_WORKERS = env.int("PASSWORD_HASH_WORKERS")
|
||||
IDEMPOTENCY_TTL_SECONDS = env.int("IDEMPOTENCY_TTL_SECONDS")
|
||||
|
||||
# S3: ключи читаются из файлов-секретов при старте, в env только пути к ним
|
||||
S3_ENDPOINT = env.str("S3_ENDPOINT")
|
||||
S3_REGION = env.str("S3_REGION")
|
||||
S3_BUCKET = env.str("S3_BUCKET")
|
||||
S3_ACCESS_KEY_ID_FILE = Path(env.str("S3_ACCESS_KEY_ID_FILE"))
|
||||
S3_SECRET_ACCESS_KEY_FILE = Path(env.str("S3_SECRET_ACCESS_KEY_FILE"))
|
||||
# Административные ключи нужны только одноразовому s3-bootstrap, не API
|
||||
S3_ADMIN_ACCESS_KEY_ID_FILE = Path(env.str("S3_ADMIN_ACCESS_KEY_ID_FILE"))
|
||||
S3_ADMIN_SECRET_ACCESS_KEY_FILE = Path(env.str("S3_ADMIN_SECRET_ACCESS_KEY_FILE"))
|
||||
S3_POOL_MAX_SIZE = env.int("S3_POOL_MAX_SIZE")
|
||||
S3_CONNECT_TIMEOUT_SEC = env.float("S3_CONNECT_TIMEOUT_SEC")
|
||||
S3_READ_TIMEOUT_SEC = env.float("S3_READ_TIMEOUT_SEC")
|
||||
S3_MAX_ATTEMPTS = env.int("S3_MAX_ATTEMPTS")
|
||||
S3_STARTUP_TIMEOUT_SEC = env.float("S3_STARTUP_TIMEOUT_SEC")
|
||||
|
||||
MAX_UPLOAD_BYTES = env.int("MAX_UPLOAD_BYTES")
|
||||
MAX_IMAGE_PIXELS = env.int("MAX_IMAGE_PIXELS")
|
||||
# Сколько байт загрузки держится в RAM, остальное — во временном файле запроса
|
||||
UPLOAD_SPOOL_MEMORY_BYTES = env.int("UPLOAD_SPOOL_MEMORY_BYTES")
|
||||
IMAGE_INSPECT_WORKERS = env.int("IMAGE_INSPECT_WORKERS")
|
||||
# Жёсткий срок PUT в S3 + подтверждения в БД; много меньше grace period janitor
|
||||
ATTACHMENT_STORE_TIMEOUT_SEC = env.float("ATTACHMENT_STORE_TIMEOUT_SEC")
|
||||
ATTACHMENT_PENDING_GRACE_SEC = env.int("ATTACHMENT_PENDING_GRACE_SEC")
|
||||
JANITOR_INTERVAL_SEC = env.float("JANITOR_INTERVAL_SEC")
|
||||
|
||||
INSTANCE_ID = secrets.token_hex(6)
|
||||
INSTANCE_ID_FILE = Path(tempfile.gettempdir()) / "instance-id"
|
||||
# Время последней успешной сверки janitor — для healthcheck его контейнера
|
||||
JANITOR_HEARTBEAT_FILE = Path(tempfile.gettempdir()) / "janitor-heartbeat"
|
||||
@@ -0,0 +1,60 @@
|
||||
from .attachments import (
|
||||
ORIGINAL_OBJECT_PREFIX,
|
||||
AttachmentContentType,
|
||||
AttachmentFilename,
|
||||
AttachmentSchema,
|
||||
AttachmentStatus,
|
||||
AttachmentVariant,
|
||||
InspectedImageSchema,
|
||||
NewAttachmentSchema,
|
||||
ReconcileReportSchema,
|
||||
StoredAttachmentSchema,
|
||||
UnfinishedUploadSchema,
|
||||
)
|
||||
from .auth import ActiveSessionSchema, BasicCredentialsSchema, SessionSchema
|
||||
from .chats import ChatPageSchema, ChatSchema, CreateChatSchema
|
||||
from .health import HealthSchema
|
||||
from .messages import (
|
||||
IDEMPOTENCY_KEY_MAX_LENGTH,
|
||||
IDEMPOTENCY_KEY_PATTERN,
|
||||
MESSAGE_ATTACHMENTS_MAX,
|
||||
CreateMessageSchema,
|
||||
IdempotencyKeySchema,
|
||||
MessagePageSchema,
|
||||
MessageSchema,
|
||||
)
|
||||
from .pagination import PageCursorSchema, PageKey
|
||||
from .users import CreateUserSchema, UserCredentialsSchema, UserSchema
|
||||
|
||||
__all__ = [
|
||||
"CreateUserSchema",
|
||||
"UserSchema",
|
||||
"UserCredentialsSchema",
|
||||
"BasicCredentialsSchema",
|
||||
"SessionSchema",
|
||||
"ActiveSessionSchema",
|
||||
"CreateChatSchema",
|
||||
"ChatSchema",
|
||||
"ChatPageSchema",
|
||||
"CreateMessageSchema",
|
||||
"IdempotencyKeySchema",
|
||||
"IDEMPOTENCY_KEY_PATTERN",
|
||||
"IDEMPOTENCY_KEY_MAX_LENGTH",
|
||||
"MESSAGE_ATTACHMENTS_MAX",
|
||||
"MessageSchema",
|
||||
"MessagePageSchema",
|
||||
"HealthSchema",
|
||||
"PageKey",
|
||||
"PageCursorSchema",
|
||||
"ORIGINAL_OBJECT_PREFIX",
|
||||
"AttachmentContentType",
|
||||
"AttachmentFilename",
|
||||
"AttachmentStatus",
|
||||
"AttachmentVariant",
|
||||
"AttachmentSchema",
|
||||
"NewAttachmentSchema",
|
||||
"StoredAttachmentSchema",
|
||||
"UnfinishedUploadSchema",
|
||||
"InspectedImageSchema",
|
||||
"ReconcileReportSchema",
|
||||
]
|
||||
@@ -0,0 +1,33 @@
|
||||
from .schemas import (
|
||||
FILENAME_MAX_LENGTH,
|
||||
ORIGINAL_OBJECT_PREFIX,
|
||||
AttachmentContentType,
|
||||
AttachmentFilename,
|
||||
AttachmentSchema,
|
||||
AttachmentStatus,
|
||||
AttachmentVariant,
|
||||
AttachmentVariantSchema,
|
||||
InspectedImageSchema,
|
||||
NewAttachmentSchema,
|
||||
ReconcileReportSchema,
|
||||
StoredAttachmentSchema,
|
||||
UnfinishedUploadSchema,
|
||||
ensure_safe_filename,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
"FILENAME_MAX_LENGTH",
|
||||
"ORIGINAL_OBJECT_PREFIX",
|
||||
"AttachmentContentType",
|
||||
"AttachmentFilename",
|
||||
"AttachmentStatus",
|
||||
"AttachmentVariant",
|
||||
"AttachmentVariantSchema",
|
||||
"AttachmentSchema",
|
||||
"NewAttachmentSchema",
|
||||
"StoredAttachmentSchema",
|
||||
"UnfinishedUploadSchema",
|
||||
"InspectedImageSchema",
|
||||
"ReconcileReportSchema",
|
||||
"ensure_safe_filename",
|
||||
]
|
||||
@@ -0,0 +1,161 @@
|
||||
import unicodedata
|
||||
from enum import StrEnum
|
||||
from typing import Annotated, Literal
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import AfterValidator, BaseModel, ConfigDict, Field
|
||||
|
||||
from domain.utils import NotBlankStr, UtcDateTime
|
||||
|
||||
FILENAME_MAX_LENGTH = 255
|
||||
|
||||
# Объекты оригиналов в bucket: ключ назначает сервер, filename в него не входит
|
||||
ORIGINAL_OBJECT_PREFIX = "originals/"
|
||||
|
||||
# Невидимое управление направлением текста: «photognp.exe» отображается
|
||||
# как «photoexe.png»
|
||||
BIDI_CONTROL_CHARACTERS = frozenset(
|
||||
""
|
||||
)
|
||||
|
||||
|
||||
def ensure_safe_filename(value: str) -> str:
|
||||
"""
|
||||
Отображаемое имя файла — не путь и не ключ S3. Запрещены разделители путей,
|
||||
управляющие символы (включая NUL), bidi-управление и имена из одних точек.
|
||||
"""
|
||||
if "/" in value or "\\" in value:
|
||||
raise ValueError("Имя файла не может содержать / или \\")
|
||||
if any(
|
||||
unicodedata.category(char) == "Cc" or char in BIDI_CONTROL_CHARACTERS
|
||||
for char in value
|
||||
):
|
||||
raise ValueError("Имя файла не может содержать управляющие символы")
|
||||
if not value.strip("."):
|
||||
raise ValueError("Имя файла не может состоять из точек")
|
||||
return value
|
||||
|
||||
|
||||
AttachmentFilename = Annotated[
|
||||
NotBlankStr,
|
||||
Field(min_length=1, max_length=FILENAME_MAX_LENGTH),
|
||||
AfterValidator(ensure_safe_filename),
|
||||
]
|
||||
|
||||
|
||||
class AttachmentContentType(StrEnum):
|
||||
"""Допустимые форматы оригинала; определяются по содержимому"""
|
||||
|
||||
PNG = "image/png"
|
||||
JPEG = "image/jpeg"
|
||||
|
||||
|
||||
class AttachmentStatus(StrEnum):
|
||||
"""
|
||||
Состояние строки вложения в БД.
|
||||
|
||||
pending — строка записана до PUT в S3; объект мог не дойти до S3
|
||||
или остаться без подтверждения (сбой между S3 и БД)
|
||||
ready — оригинал в S3 и метаданные подтверждены; только его видит API
|
||||
deleting — незавершённая загрузка забрана на очистку: сначала удаляется
|
||||
объект S3, затем строка
|
||||
"""
|
||||
|
||||
PENDING = "pending"
|
||||
READY = "ready"
|
||||
DELETING = "deleting"
|
||||
|
||||
|
||||
class AttachmentVariant(StrEnum):
|
||||
"""Имена вариантов из контракта; в lab4 существует только original"""
|
||||
|
||||
ORIGINAL = "original"
|
||||
THUMBNAIL = "thumbnail"
|
||||
CROP = "crop"
|
||||
OPTIMIZED = "optimized"
|
||||
|
||||
|
||||
class AttachmentVariantSchema(BaseModel):
|
||||
"""Производный вариант изображения; появляется с lab5"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
name: AttachmentVariant
|
||||
content_type: str
|
||||
size_bytes: int
|
||||
width: int
|
||||
height: int
|
||||
sha256: str
|
||||
|
||||
|
||||
class AttachmentSchema(BaseModel):
|
||||
"""Метаданные вложения; size_bytes, sha256 и content_type описывают оригинал"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
id: UUID
|
||||
chat_id: UUID
|
||||
owner_id: UUID
|
||||
filename: str
|
||||
content_type: AttachmentContentType
|
||||
size_bytes: int
|
||||
sha256: str
|
||||
status: Literal["ready"] = "ready"
|
||||
variants: list[AttachmentVariantSchema] = Field(default_factory=list)
|
||||
error_code: str | None = None
|
||||
created_at: UtcDateTime
|
||||
updated_at: UtcDateTime
|
||||
|
||||
|
||||
class NewAttachmentSchema(BaseModel):
|
||||
"""Проверенная загрузка: метаданные и назначенный сервером ключ объекта S3"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
chat_id: UUID
|
||||
owner_id: UUID
|
||||
filename: str
|
||||
content_type: AttachmentContentType
|
||||
size_bytes: int
|
||||
sha256: bytes
|
||||
object_key: str
|
||||
|
||||
|
||||
class StoredAttachmentSchema(BaseModel):
|
||||
"""Вложение вместе с ключом объекта — только внутри приложения"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
attachment: AttachmentSchema
|
||||
object_key: str
|
||||
|
||||
|
||||
class UnfinishedUploadSchema(BaseModel):
|
||||
"""Строка pending/deleting, забранная на очистку, и её объект S3"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
id: UUID
|
||||
object_key: str
|
||||
|
||||
|
||||
class InspectedImageSchema(BaseModel):
|
||||
"""Результат проверки содержимого: истинный формат и размеры"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
content_type: AttachmentContentType
|
||||
width: int
|
||||
height: int
|
||||
|
||||
|
||||
class ReconcileReportSchema(BaseModel):
|
||||
"""Итог одного прохода сверки S3 и БД"""
|
||||
|
||||
dry_run: bool
|
||||
unfinished_claimed: int = 0
|
||||
unfinished_objects_deleted: int = 0
|
||||
unfinished_rows_deleted: int = 0
|
||||
objects_scanned: int = 0
|
||||
orphan_objects_found: int = 0
|
||||
orphan_objects_deleted: int = 0
|
||||
@@ -0,0 +1,7 @@
|
||||
from .schemas import ActiveSessionSchema, BasicCredentialsSchema, SessionSchema
|
||||
|
||||
__all__ = [
|
||||
"BasicCredentialsSchema",
|
||||
"SessionSchema",
|
||||
"ActiveSessionSchema",
|
||||
]
|
||||
@@ -0,0 +1,35 @@
|
||||
from typing import Literal
|
||||
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
from domain.users import UserSchema
|
||||
from domain.utils import UtcDateTime
|
||||
|
||||
|
||||
class BasicCredentialsSchema(BaseModel):
|
||||
"""Разобранный заголовок Authorization: Basic"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
username: str
|
||||
password: str
|
||||
|
||||
|
||||
class SessionSchema(BaseModel):
|
||||
"""Ответ входа: непрозрачный токен показывается клиенту один раз"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
token: str
|
||||
token_type: Literal["Bearer"] = "Bearer"
|
||||
expires_at: UtcDateTime
|
||||
user: UserSchema
|
||||
|
||||
|
||||
class ActiveSessionSchema(BaseModel):
|
||||
"""Действующая серверная сессия: владелец и срок; так же лежит в кэше"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
user: UserSchema
|
||||
expires_at: UtcDateTime
|
||||
@@ -0,0 +1,7 @@
|
||||
from .schemas import ChatPageSchema, ChatSchema, CreateChatSchema
|
||||
|
||||
__all__ = [
|
||||
"CreateChatSchema",
|
||||
"ChatSchema",
|
||||
"ChatPageSchema",
|
||||
]
|
||||
@@ -0,0 +1,42 @@
|
||||
from typing import Annotated
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field, field_validator
|
||||
|
||||
from domain.utils import NotBlankStr, UtcDateTime
|
||||
|
||||
ChatTitle = Annotated[NotBlankStr, Field(min_length=1, max_length=100)]
|
||||
|
||||
|
||||
class CreateChatSchema(BaseModel):
|
||||
"""Запрос создания чата: участники задаются явно, включая вызывающего"""
|
||||
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
title: ChatTitle
|
||||
member_ids: list[UUID] = Field(min_length=1, max_length=100)
|
||||
|
||||
@field_validator("member_ids")
|
||||
@classmethod
|
||||
def validate_unique_members(cls, value: list[UUID]) -> list[UUID]:
|
||||
if len(set(value)) != len(value):
|
||||
raise ValueError("member_ids не должен содержать дубликаты")
|
||||
return value
|
||||
|
||||
|
||||
class ChatSchema(BaseModel):
|
||||
"""Чат"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
id: UUID
|
||||
title: str
|
||||
member_ids: list[UUID]
|
||||
created_at: UtcDateTime
|
||||
|
||||
|
||||
class ChatPageSchema(BaseModel):
|
||||
"""Страница чатов текущего пользователя"""
|
||||
|
||||
items: list[ChatSchema]
|
||||
next_cursor: str | None
|
||||
@@ -0,0 +1,28 @@
|
||||
from .codes import ErrorCode
|
||||
from .exceptions import (
|
||||
AppError,
|
||||
ConflictError,
|
||||
InvalidCredentialsError,
|
||||
InvalidRequestError,
|
||||
NotFoundError,
|
||||
PayloadTooLargeError,
|
||||
UnauthorizedError,
|
||||
UnavailableError,
|
||||
UnsupportedMediaTypeError,
|
||||
)
|
||||
from .schemas import ErrorBodySchema, ErrorSchema
|
||||
|
||||
__all__ = [
|
||||
"ErrorCode",
|
||||
"AppError",
|
||||
"InvalidRequestError",
|
||||
"UnauthorizedError",
|
||||
"InvalidCredentialsError",
|
||||
"NotFoundError",
|
||||
"ConflictError",
|
||||
"PayloadTooLargeError",
|
||||
"UnsupportedMediaTypeError",
|
||||
"UnavailableError",
|
||||
"ErrorBodySchema",
|
||||
"ErrorSchema",
|
||||
]
|
||||
@@ -0,0 +1,15 @@
|
||||
from enum import StrEnum
|
||||
|
||||
|
||||
class ErrorCode(StrEnum):
|
||||
"""коды ошибок"""
|
||||
|
||||
INVALID_REQUEST = "invalid_request"
|
||||
UNAUTHORIZED = "unauthorized"
|
||||
NOT_FOUND = "not_found"
|
||||
CONFLICT = "conflict"
|
||||
PAYLOAD_TOO_LARGE = "payload_too_large"
|
||||
UNSUPPORTED_MEDIA_TYPE = "unsupported_media_type"
|
||||
RATE_LIMITED = "rate_limited"
|
||||
UNAVAILABLE = "unavailable"
|
||||
INTERNAL_ERROR = "internal_error"
|
||||
@@ -0,0 +1,80 @@
|
||||
from http import HTTPStatus
|
||||
|
||||
from .codes import ErrorCode
|
||||
|
||||
|
||||
class AppError(Exception):
|
||||
"""Базовая ошибка приложения: статус, машинный код и безопасное сообщение"""
|
||||
|
||||
status_code: HTTPStatus = HTTPStatus.INTERNAL_SERVER_ERROR
|
||||
code: ErrorCode = ErrorCode.INTERNAL_ERROR
|
||||
default_message: str = "Внутренняя ошибка сервера"
|
||||
headers: dict[str, str] = {}
|
||||
|
||||
def __init__(self, message: str | None = None) -> None:
|
||||
self.message = message or self.default_message
|
||||
super().__init__(self.message)
|
||||
|
||||
|
||||
class InvalidRequestError(AppError):
|
||||
"""Неверные поля, UUID, cursor или limit"""
|
||||
|
||||
status_code = HTTPStatus.BAD_REQUEST
|
||||
code = ErrorCode.INVALID_REQUEST
|
||||
default_message = "Некорректный запрос"
|
||||
|
||||
|
||||
class UnauthorizedError(AppError):
|
||||
"""Нет действительной Bearer-сессии: токена нет, он истёк, отозван или неизвестен"""
|
||||
|
||||
status_code = HTTPStatus.UNAUTHORIZED
|
||||
code = ErrorCode.UNAUTHORIZED
|
||||
default_message = "Требуется действительная сессия: Authorization: Bearer <token>"
|
||||
headers = {"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
|
||||
|
||||
class InvalidCredentialsError(UnauthorizedError):
|
||||
"""Неверные Basic-credentials: одинаковый ответ для неизвестного логина и пароля"""
|
||||
|
||||
default_message = "Неверное имя пользователя или пароль"
|
||||
headers = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
|
||||
|
||||
|
||||
class NotFoundError(AppError):
|
||||
"""Объекта нет или он чужой: существование чужого объекта не раскрывается"""
|
||||
|
||||
status_code = HTTPStatus.NOT_FOUND
|
||||
code = ErrorCode.NOT_FOUND
|
||||
default_message = "Объект не найден"
|
||||
|
||||
|
||||
class ConflictError(AppError):
|
||||
"""Конфликт состояния, например занятый username"""
|
||||
|
||||
status_code = HTTPStatus.CONFLICT
|
||||
code = ErrorCode.CONFLICT
|
||||
default_message = "Конфликт состояния"
|
||||
|
||||
|
||||
class PayloadTooLargeError(AppError):
|
||||
"""Тело больше лимита байт или изображение больше лимита пикселей"""
|
||||
|
||||
status_code = HTTPStatus.REQUEST_ENTITY_TOO_LARGE
|
||||
code = ErrorCode.PAYLOAD_TOO_LARGE
|
||||
default_message = "Слишком большой файл"
|
||||
|
||||
|
||||
class UnsupportedMediaTypeError(AppError):
|
||||
"""Содержимое не PNG/JPEG, повреждено или не совпадает с Content-Type"""
|
||||
|
||||
status_code = HTTPStatus.UNSUPPORTED_MEDIA_TYPE
|
||||
code = ErrorCode.UNSUPPORTED_MEDIA_TYPE
|
||||
default_message = "Поддерживаются только изображения PNG и JPEG"
|
||||
|
||||
|
||||
class UnavailableError(AppError):
|
||||
"""Приложение не готово обслуживать запросы"""
|
||||
|
||||
status_code = HTTPStatus.SERVICE_UNAVAILABLE
|
||||
code = ErrorCode.UNAVAILABLE
|
||||
default_message = "Сервис временно недоступен"
|
||||
@@ -0,0 +1,21 @@
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
from .codes import ErrorCode
|
||||
|
||||
|
||||
class ErrorBodySchema(BaseModel):
|
||||
"""Тело ошибки"""
|
||||
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
code: ErrorCode
|
||||
message: str
|
||||
request_id: str
|
||||
|
||||
|
||||
class ErrorSchema(BaseModel):
|
||||
"""Единый формат ошибки: {"error": {...}}"""
|
||||
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
error: ErrorBodySchema
|
||||
@@ -0,0 +1,3 @@
|
||||
from .schemas import HealthSchema
|
||||
|
||||
__all__ = ["HealthSchema"]
|
||||
@@ -0,0 +1,9 @@
|
||||
from typing import Literal
|
||||
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class HealthSchema(BaseModel):
|
||||
"""Ответ health-проверок"""
|
||||
|
||||
status: Literal["ok"] = "ok"
|
||||
@@ -0,0 +1,19 @@
|
||||
from .schemas import (
|
||||
IDEMPOTENCY_KEY_MAX_LENGTH,
|
||||
IDEMPOTENCY_KEY_PATTERN,
|
||||
MESSAGE_ATTACHMENTS_MAX,
|
||||
CreateMessageSchema,
|
||||
IdempotencyKeySchema,
|
||||
MessagePageSchema,
|
||||
MessageSchema,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
"IDEMPOTENCY_KEY_PATTERN",
|
||||
"IDEMPOTENCY_KEY_MAX_LENGTH",
|
||||
"MESSAGE_ATTACHMENTS_MAX",
|
||||
"CreateMessageSchema",
|
||||
"IdempotencyKeySchema",
|
||||
"MessageSchema",
|
||||
"MessagePageSchema",
|
||||
]
|
||||
@@ -0,0 +1,85 @@
|
||||
from typing import Annotated, Self
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import (
|
||||
AfterValidator,
|
||||
BaseModel,
|
||||
ConfigDict,
|
||||
Field,
|
||||
StrictStr,
|
||||
field_validator,
|
||||
model_validator,
|
||||
)
|
||||
|
||||
from domain.utils import UtcDateTime, ensure_not_blank, ensure_storable
|
||||
|
||||
MessageText = Annotated[
|
||||
StrictStr, Field(max_length=4000), AfterValidator(ensure_storable)
|
||||
]
|
||||
|
||||
MESSAGE_ATTACHMENTS_MAX = 10
|
||||
|
||||
IDEMPOTENCY_KEY_PATTERN = r"^[A-Za-z0-9._:-]{1,128}$"
|
||||
IDEMPOTENCY_KEY_MAX_LENGTH = 128
|
||||
|
||||
|
||||
class CreateMessageSchema(BaseModel):
|
||||
"""
|
||||
Запрос отправки сообщения: отправитель берётся из текущей сессии.
|
||||
Пустой или пробельный текст допустим только вместе с вложениями.
|
||||
"""
|
||||
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
text: MessageText
|
||||
attachment_ids: list[UUID] = Field(
|
||||
default_factory=list, max_length=MESSAGE_ATTACHMENTS_MAX
|
||||
)
|
||||
|
||||
@field_validator("attachment_ids")
|
||||
@classmethod
|
||||
def validate_unique_attachments(cls, value: list[UUID]) -> list[UUID]:
|
||||
if len(set(value)) != len(value):
|
||||
raise ValueError("attachment_ids не должен содержать дубликаты")
|
||||
return value
|
||||
|
||||
@model_validator(mode="after")
|
||||
def validate_not_empty(self) -> Self:
|
||||
if not self.attachment_ids:
|
||||
ensure_not_blank(self.text)
|
||||
return self
|
||||
|
||||
|
||||
class MessageSchema(BaseModel):
|
||||
"""Сообщение"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
id: UUID
|
||||
chat_id: UUID
|
||||
sender_id: UUID
|
||||
text: str
|
||||
created_at: UtcDateTime
|
||||
attachment_ids: list[UUID]
|
||||
|
||||
|
||||
class MessagePageSchema(BaseModel):
|
||||
"""Страница истории чата"""
|
||||
|
||||
items: list[MessageSchema]
|
||||
next_cursor: str | None
|
||||
|
||||
|
||||
class IdempotencyKeySchema(BaseModel):
|
||||
"""
|
||||
Ключ повторной отправки сообщения.
|
||||
|
||||
request_hash — SHA-256 канонического тела: повтор с тем же ключом и тем же
|
||||
телом возвращает исходное сообщение, с другим телом — конфликт.
|
||||
"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
key: str
|
||||
request_hash: bytes
|
||||
ttl_seconds: int
|
||||
@@ -0,0 +1,6 @@
|
||||
from .schemas import PageCursorSchema, PageKey
|
||||
|
||||
__all__ = [
|
||||
"PageKey",
|
||||
"PageCursorSchema",
|
||||
]
|
||||
@@ -0,0 +1,26 @@
|
||||
from datetime import datetime
|
||||
from typing import NamedTuple
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
|
||||
class PageKey(NamedTuple):
|
||||
"""Ключ keyset-пагинации: порядок (created_at, id) по возрастанию"""
|
||||
|
||||
created_at: datetime
|
||||
id: UUID
|
||||
|
||||
|
||||
class PageCursorSchema(BaseModel):
|
||||
"""Содержимое непрозрачного cursor: ключ последнего элемента и его ресурс"""
|
||||
|
||||
model_config = ConfigDict(extra="forbid", frozen=True)
|
||||
|
||||
scope: str
|
||||
created_at: datetime
|
||||
id: UUID
|
||||
|
||||
@property
|
||||
def key(self) -> PageKey:
|
||||
return PageKey(self.created_at, self.id)
|
||||
@@ -0,0 +1,7 @@
|
||||
from .schemas import CreateUserSchema, UserCredentialsSchema, UserSchema
|
||||
|
||||
__all__ = [
|
||||
"CreateUserSchema",
|
||||
"UserSchema",
|
||||
"UserCredentialsSchema",
|
||||
]
|
||||
@@ -0,0 +1,40 @@
|
||||
from typing import Annotated
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field, StrictStr
|
||||
|
||||
from domain.utils import NotBlankStr, UtcDateTime
|
||||
|
||||
Username = Annotated[StrictStr, Field(pattern=r"^[a-z0-9_]{3,32}$")]
|
||||
DisplayName = Annotated[NotBlankStr, Field(min_length=1, max_length=100)]
|
||||
Password = Annotated[StrictStr, Field(min_length=12, max_length=128)]
|
||||
|
||||
|
||||
class CreateUserSchema(BaseModel):
|
||||
"""Запрос регистрации пользователя; длина пароля — в Unicode code points"""
|
||||
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
username: Username
|
||||
display_name: DisplayName
|
||||
password: Password = Field(json_schema_extra={"writeOnly": True})
|
||||
|
||||
|
||||
class UserSchema(BaseModel):
|
||||
"""Пользователь: пароль и его hash сюда никогда не попадают"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
id: UUID
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: UtcDateTime
|
||||
|
||||
|
||||
class UserCredentialsSchema(BaseModel):
|
||||
"""Пользователь вместе с hash пароля — только для проверки входа"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
user: UserSchema
|
||||
password_hash: str
|
||||
@@ -0,0 +1,15 @@
|
||||
from .types import (
|
||||
NotBlankStr,
|
||||
UtcDateTime,
|
||||
ensure_not_blank,
|
||||
ensure_storable,
|
||||
to_rfc3339_utc,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
"NotBlankStr",
|
||||
"UtcDateTime",
|
||||
"ensure_not_blank",
|
||||
"ensure_storable",
|
||||
"to_rfc3339_utc",
|
||||
]
|
||||
@@ -0,0 +1,36 @@
|
||||
from datetime import UTC, datetime
|
||||
from typing import Annotated
|
||||
|
||||
from pydantic import AfterValidator, PlainSerializer, StrictStr
|
||||
|
||||
NUL_CHARACTER = "\x00"
|
||||
|
||||
|
||||
def ensure_not_blank(value: str) -> str:
|
||||
"""Обязательная строка не может состоять только из пробельных символов"""
|
||||
if not value.strip():
|
||||
raise ValueError("Строка не может быть пустой или пробельной")
|
||||
return value
|
||||
|
||||
|
||||
def ensure_storable(value: str) -> str:
|
||||
"""Тип text в потсгре"""
|
||||
if NUL_CHARACTER in value:
|
||||
raise ValueError("Строка не может содержать символ NUL")
|
||||
return value
|
||||
|
||||
|
||||
def to_rfc3339_utc(value: datetime) -> str:
|
||||
"""RFC 3339 в UTC с суффиксом Z и микросекундами"""
|
||||
return (
|
||||
value.astimezone(UTC).isoformat(timespec="microseconds").replace("+00:00", "Z")
|
||||
)
|
||||
|
||||
|
||||
NotBlankStr = Annotated[
|
||||
StrictStr, AfterValidator(ensure_not_blank), AfterValidator(ensure_storable)
|
||||
]
|
||||
|
||||
UtcDateTime = Annotated[
|
||||
datetime, PlainSerializer(to_rfc3339_utc, return_type=str, when_used="json")
|
||||
]
|
||||
+147
@@ -0,0 +1,147 @@
|
||||
import asyncio
|
||||
import socket
|
||||
from collections.abc import AsyncIterator
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
import uvicorn
|
||||
from fastapi import FastAPI
|
||||
|
||||
from application import api_endpoints, health_endpoints
|
||||
from application.api.handlers import register_exception_handlers
|
||||
from application.api.middlewares import RequestContextMiddleware
|
||||
from config import (
|
||||
APP_ENV,
|
||||
APP_HOST,
|
||||
APP_KEEPALIVE_TIMEOUT_SEC,
|
||||
APP_PORT,
|
||||
APP_REVISION,
|
||||
DB_STARTUP_TIMEOUT_SEC,
|
||||
IMAGE_INSPECT_WORKERS,
|
||||
INSTANCE_ID,
|
||||
INSTANCE_ID_FILE,
|
||||
LOGGER,
|
||||
MAX_IMAGE_PIXELS,
|
||||
PASSWORD_HASH_WORKERS,
|
||||
SESSION_TTL_SECONDS,
|
||||
SHUTDOWN_DRAIN_SEC,
|
||||
SHUTDOWN_TIMEOUT_SEC,
|
||||
)
|
||||
from infrastructure import (
|
||||
ImageInspector,
|
||||
PasswordHasher,
|
||||
cache_manager,
|
||||
database_pool_manager,
|
||||
storage_manager,
|
||||
)
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
|
||||
"""
|
||||
uvicorn открывает порт только после startup: реплика без БД или со старой
|
||||
схемой не принимает соединений, и LB отправляет запросы другим репликам.
|
||||
|
||||
S3 на старт не влияет: реплика стартует и обслуживает сообщения,
|
||||
а readiness остаётся 503, пока bucket недоступен.
|
||||
"""
|
||||
await database_pool_manager.create_pool(DB_STARTUP_TIMEOUT_SEC)
|
||||
await database_pool_manager.check_migrations()
|
||||
cache_manager.create_client()
|
||||
await storage_manager.create_client()
|
||||
if await storage_manager.check():
|
||||
LOGGER.info("Bucket S3 доступен")
|
||||
else:
|
||||
LOGGER.warning("Bucket S3 недоступен: вложения отвечают 503")
|
||||
password_hasher = PasswordHasher(PASSWORD_HASH_WORKERS)
|
||||
image_inspector = ImageInspector(IMAGE_INSPECT_WORKERS, MAX_IMAGE_PIXELS)
|
||||
app.state.database = database_pool_manager
|
||||
app.state.cache = cache_manager
|
||||
app.state.storage = storage_manager
|
||||
app.state.password_hasher = password_hasher
|
||||
app.state.image_inspector = image_inspector
|
||||
INSTANCE_ID_FILE.write_text(INSTANCE_ID)
|
||||
app.state.is_ready = True
|
||||
LOGGER.info(
|
||||
f"Application started, env={APP_ENV}, revision={APP_REVISION}, "
|
||||
f"instance={INSTANCE_ID}, session ttl={SESSION_TTL_SECONDS} s"
|
||||
)
|
||||
yield
|
||||
app.state.is_ready = False
|
||||
await cache_manager.close()
|
||||
await storage_manager.close()
|
||||
await database_pool_manager.close()
|
||||
password_hasher.close()
|
||||
image_inspector.close()
|
||||
LOGGER.info(f"Application stopped, instance={INSTANCE_ID}, connections closed")
|
||||
|
||||
|
||||
app = FastAPI(
|
||||
title="mtuci-labs-messanger",
|
||||
description="мессенджер-конкурент-максу",
|
||||
version="1.4.0",
|
||||
lifespan=lifespan,
|
||||
)
|
||||
|
||||
app.add_middleware(RequestContextMiddleware)
|
||||
register_exception_handlers(app)
|
||||
|
||||
app.include_router(health_endpoints)
|
||||
app.include_router(api_endpoints)
|
||||
|
||||
|
||||
class DrainingServer(uvicorn.Server):
|
||||
"""
|
||||
SIGTERM: сначала drain, затем штатный graceful shutdown uvicorn.
|
||||
"""
|
||||
|
||||
def __init__(self, config: uvicorn.Config, drain_seconds: float) -> None:
|
||||
super().__init__(config)
|
||||
self._drain_seconds = drain_seconds
|
||||
|
||||
async def shutdown(self, sockets: list[socket.socket] | None = None) -> None:
|
||||
for server in getattr(self, "servers", []):
|
||||
server.close()
|
||||
app.state.is_ready = False
|
||||
app.state.is_draining = True
|
||||
LOGGER.info(
|
||||
f"SIGTERM: drain {self._drain_seconds} с, instance={INSTANCE_ID}: "
|
||||
"порт закрыт, keep-alive соединения закрываются после ответа"
|
||||
)
|
||||
await asyncio.sleep(self._drain_seconds)
|
||||
await super().shutdown(sockets)
|
||||
|
||||
|
||||
def main(
|
||||
host: str,
|
||||
port: int,
|
||||
shutdown_timeout: int,
|
||||
keepalive_timeout: int,
|
||||
drain_seconds: float,
|
||||
) -> None:
|
||||
"""
|
||||
Функция для запуска api.
|
||||
|
||||
SIGTERM: drain_seconds без приёма новых соединений, затем uvicorn ждёт
|
||||
текущих запросов не дольше shutdown_timeout, и lifespan закрывает пулы.
|
||||
Сумма меньше stop_grace_period контейнера (10 с).
|
||||
"""
|
||||
config = uvicorn.Config(
|
||||
app,
|
||||
host=host,
|
||||
port=port,
|
||||
timeout_graceful_shutdown=shutdown_timeout,
|
||||
timeout_keep_alive=keepalive_timeout,
|
||||
access_log=False,
|
||||
server_header=False,
|
||||
)
|
||||
DrainingServer(config, drain_seconds).run()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main(
|
||||
host=APP_HOST,
|
||||
port=APP_PORT,
|
||||
shutdown_timeout=SHUTDOWN_TIMEOUT_SEC,
|
||||
keepalive_timeout=APP_KEEPALIVE_TIMEOUT_SEC,
|
||||
drain_seconds=SHUTDOWN_DRAIN_SEC,
|
||||
)
|
||||
@@ -0,0 +1,33 @@
|
||||
import sys
|
||||
import time
|
||||
import urllib.request
|
||||
|
||||
from config import APP_PORT, JANITOR_HEARTBEAT_FILE, JANITOR_INTERVAL_SEC
|
||||
|
||||
READY_URL = f"http://127.0.0.1:{APP_PORT}/health/ready"
|
||||
|
||||
REQUEST_TIMEOUT_SEC = 2
|
||||
|
||||
# janitor считается зависшим, если пропустил несколько проходов подряд
|
||||
JANITOR_MAX_SILENCE_SEC = 3 * JANITOR_INTERVAL_SEC
|
||||
|
||||
|
||||
def api() -> int:
|
||||
try:
|
||||
with urllib.request.urlopen(READY_URL, timeout=REQUEST_TIMEOUT_SEC) as response:
|
||||
return 0 if response.status == 200 else 1
|
||||
except OSError:
|
||||
return 1
|
||||
|
||||
|
||||
def janitor() -> int:
|
||||
"""Последняя успешная сверка была недавно"""
|
||||
try:
|
||||
age = time.time() - JANITOR_HEARTBEAT_FILE.stat().st_mtime
|
||||
except OSError:
|
||||
return 1
|
||||
return 0 if age < JANITOR_MAX_SILENCE_SEC else 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(janitor() if sys.argv[1:] == ["janitor"] else api())
|
||||
@@ -0,0 +1,11 @@
|
||||
from .dependencies import cache_manager, database_pool_manager, storage_manager
|
||||
from .media import ImageInspector
|
||||
from .security import PasswordHasher
|
||||
|
||||
__all__ = [
|
||||
"database_pool_manager",
|
||||
"cache_manager",
|
||||
"storage_manager",
|
||||
"PasswordHasher",
|
||||
"ImageInspector",
|
||||
]
|
||||
@@ -0,0 +1,17 @@
|
||||
from .cache import CacheManager, cache_manager, get_cache
|
||||
from .database import DatabasePoolManager, database_pool_manager, get_database
|
||||
from .service_creator import ServiceCreator
|
||||
from .storage import ObjectStorageManager, get_storage, storage_manager
|
||||
|
||||
__all__ = [
|
||||
"ServiceCreator",
|
||||
"DatabasePoolManager",
|
||||
"database_pool_manager",
|
||||
"get_database",
|
||||
"CacheManager",
|
||||
"cache_manager",
|
||||
"get_cache",
|
||||
"ObjectStorageManager",
|
||||
"storage_manager",
|
||||
"get_storage",
|
||||
]
|
||||
@@ -0,0 +1,94 @@
|
||||
import time
|
||||
|
||||
from redis.asyncio import BlockingConnectionPool, Redis
|
||||
from redis.asyncio.retry import Retry
|
||||
from redis.backoff import NoBackoff
|
||||
from starlette.requests import HTTPConnection
|
||||
|
||||
from config import (
|
||||
LOGGER,
|
||||
VALKEY_HOST,
|
||||
VALKEY_PASS,
|
||||
VALKEY_POOL_MAX_SIZE,
|
||||
VALKEY_PORT,
|
||||
VALKEY_RETRY_AFTER_SEC,
|
||||
VALKEY_TIMEOUT_SEC,
|
||||
)
|
||||
|
||||
|
||||
class CacheManager:
|
||||
"""
|
||||
Клиент Valkey: ограниченный пул, короткие таймауты, без встроенных повторов.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
host: str,
|
||||
port: int,
|
||||
password: str,
|
||||
max_size: int,
|
||||
timeout: float,
|
||||
retry_after: float,
|
||||
) -> None:
|
||||
self._host = host
|
||||
self._port = port
|
||||
self._password = password
|
||||
self.max_size = max_size
|
||||
self.timeout = timeout
|
||||
self.retry_after = retry_after
|
||||
self.client: Redis | None = None
|
||||
self._disabled_until = 0.0
|
||||
|
||||
def create_client(self) -> Redis:
|
||||
"""Создание клиента; соединения открываются лениво при первом запросе"""
|
||||
if self.client is None:
|
||||
pool = BlockingConnectionPool(
|
||||
host=self._host,
|
||||
port=self._port,
|
||||
password=self._password,
|
||||
max_connections=self.max_size,
|
||||
timeout=self.timeout,
|
||||
socket_timeout=self.timeout,
|
||||
socket_connect_timeout=self.timeout,
|
||||
retry=Retry(NoBackoff(), 0),
|
||||
)
|
||||
self.client = Redis(connection_pool=pool)
|
||||
LOGGER.info(
|
||||
f"Клиент Valkey создан: {self._host}:{self._port}, "
|
||||
f"pool: {self.max_size}, timeout: {self.timeout} с"
|
||||
)
|
||||
return self.client
|
||||
|
||||
@property
|
||||
def is_available(self) -> bool:
|
||||
return time.monotonic() >= self._disabled_until
|
||||
|
||||
def mark_failed(self, error: Exception) -> None:
|
||||
"""Обход кэша на retry_after секунд после ошибки Valkey"""
|
||||
if self.is_available:
|
||||
LOGGER.warning(
|
||||
f"Valkey недоступен ({type(error).__name__}): кэш сессий "
|
||||
f"обходится {self.retry_after} с, запросы идут в PostgreSQL"
|
||||
)
|
||||
self._disabled_until = time.monotonic() + self.retry_after
|
||||
|
||||
async def close(self) -> None:
|
||||
if self.client is not None:
|
||||
await self.client.aclose()
|
||||
self.client = None
|
||||
|
||||
|
||||
def get_cache(connection: HTTPConnection) -> CacheManager:
|
||||
"""Получение менеджера кэша, созданного в lifespan."""
|
||||
cache: CacheManager = connection.app.state.cache
|
||||
return cache
|
||||
|
||||
|
||||
cache_manager = CacheManager(
|
||||
host=VALKEY_HOST,
|
||||
port=VALKEY_PORT,
|
||||
password=VALKEY_PASS,
|
||||
max_size=VALKEY_POOL_MAX_SIZE,
|
||||
timeout=VALKEY_TIMEOUT_SEC,
|
||||
retry_after=VALKEY_RETRY_AFTER_SEC,
|
||||
)
|
||||
@@ -0,0 +1,236 @@
|
||||
import asyncio
|
||||
import time
|
||||
from collections.abc import AsyncIterator
|
||||
from contextlib import asynccontextmanager
|
||||
from pathlib import Path
|
||||
|
||||
import asyncpg
|
||||
from starlette.requests import HTTPConnection
|
||||
|
||||
from config import (
|
||||
DB_COMMAND_TIMEOUT_SEC,
|
||||
DB_CONNECT_TIMEOUT_SEC,
|
||||
DB_HOST,
|
||||
DB_NAME,
|
||||
DB_PASS,
|
||||
DB_POOL_MAX_SIZE,
|
||||
DB_POOL_MIN_SIZE,
|
||||
DB_PORT,
|
||||
DB_USER,
|
||||
LOGGER,
|
||||
)
|
||||
from infrastructure.utils import DATABASE_UNAVAILABLE_ERRORS
|
||||
|
||||
MIGRATIONS_DIR = Path(__file__).resolve().parents[3] / "migrations"
|
||||
|
||||
MIGRATIONS_LOCK_NAMESPACE = 1
|
||||
|
||||
STARTUP_RETRY_INTERVAL_SEC = 1
|
||||
|
||||
BROKEN_CONNECTION_ERRORS: tuple[type[Exception], ...] = (
|
||||
asyncpg.PostgresConnectionError,
|
||||
asyncpg.InterfaceError,
|
||||
asyncpg.exceptions.OperatorInterventionError,
|
||||
)
|
||||
|
||||
MIGRATIONS_TIMEOUT_SEC = 300
|
||||
|
||||
|
||||
class DatabasePoolManager:
|
||||
"""Класс для управления пулом соединений и версионируемыми миграциями."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
user: str,
|
||||
password: str,
|
||||
db: str,
|
||||
host: str,
|
||||
port: int,
|
||||
min_size: int,
|
||||
max_size: int,
|
||||
connect_timeout: float,
|
||||
command_timeout: float,
|
||||
) -> None:
|
||||
self._user = user
|
||||
self._password = password
|
||||
self._host = host
|
||||
self._port = port
|
||||
self._database = db
|
||||
self.min_size = min_size
|
||||
self.max_size = max_size
|
||||
self.connect_timeout = connect_timeout
|
||||
self.command_timeout = command_timeout
|
||||
self.pool: asyncpg.Pool | None = None
|
||||
|
||||
async def create_pool(self, startup_timeout: float) -> asyncpg.Pool:
|
||||
"""
|
||||
Создание ограниченного пула соединений.
|
||||
"""
|
||||
LOGGER.info("Установка соединения с базой данных psql")
|
||||
deadline = time.monotonic() + startup_timeout
|
||||
while self.pool is None:
|
||||
try:
|
||||
self.pool = await asyncpg.create_pool(
|
||||
user=self._user,
|
||||
password=self._password,
|
||||
host=self._host,
|
||||
port=self._port,
|
||||
database=self._database,
|
||||
min_size=self.min_size,
|
||||
max_size=self.max_size,
|
||||
timeout=self.connect_timeout,
|
||||
command_timeout=self.command_timeout,
|
||||
server_settings={
|
||||
"application_name": "messenger-api",
|
||||
"statement_timeout": str(int(self.command_timeout * 1000)),
|
||||
},
|
||||
)
|
||||
except (*DATABASE_UNAVAILABLE_ERRORS, asyncpg.PostgresError) as error:
|
||||
if time.monotonic() >= deadline:
|
||||
LOGGER.error(
|
||||
"Не удалось подключиться к psql за "
|
||||
f"{startup_timeout} с: {type(error).__name__}"
|
||||
)
|
||||
raise
|
||||
LOGGER.warning(
|
||||
f"PostgreSQL ещё недоступен: {type(error).__name__}, повтор"
|
||||
)
|
||||
await asyncio.sleep(STARTUP_RETRY_INTERVAL_SEC)
|
||||
LOGGER.info(
|
||||
f"Соединение с базой данных psql установлено. DB_NAME: "
|
||||
f"{self._database}, pool: {self.min_size}..{self.max_size}"
|
||||
)
|
||||
return self.pool
|
||||
|
||||
async def apply_migrations(self, directory: Path = MIGRATIONS_DIR) -> None:
|
||||
"""
|
||||
Применение миграций NNNN_name.sql по порядку версий.
|
||||
|
||||
Вызывается однократно отдельным процессом (src/migrate.py, сервис migrate)
|
||||
до запуска API-реплик, а не каждой репликой при старте.
|
||||
Каждая миграция и запись о ней в schema_migrations — одна транзакция.
|
||||
Advisory lock — страховка от двух одновременных запусков migrate;
|
||||
уже применённые версии пропускаются, поэтому повторный запуск безопасен.
|
||||
"""
|
||||
async with self.acquire() as conn:
|
||||
await conn.execute("SET statement_timeout = 0;")
|
||||
await conn.execute(
|
||||
"SELECT pg_advisory_lock($1, 0);",
|
||||
MIGRATIONS_LOCK_NAMESPACE,
|
||||
timeout=MIGRATIONS_TIMEOUT_SEC,
|
||||
)
|
||||
try:
|
||||
await conn.execute(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version integer PRIMARY KEY,
|
||||
name text NOT NULL,
|
||||
applied_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
"""
|
||||
)
|
||||
applied = {
|
||||
record["version"]
|
||||
for record in await conn.fetch(
|
||||
"SELECT version FROM schema_migrations;"
|
||||
)
|
||||
}
|
||||
for version, path in self._migration_files(directory):
|
||||
if version in applied:
|
||||
continue
|
||||
async with conn.transaction():
|
||||
await conn.execute(
|
||||
path.read_text(encoding="utf-8"),
|
||||
timeout=MIGRATIONS_TIMEOUT_SEC,
|
||||
)
|
||||
await conn.execute(
|
||||
"INSERT INTO schema_migrations (version, name) "
|
||||
"VALUES ($1, $2);",
|
||||
version,
|
||||
path.stem,
|
||||
)
|
||||
LOGGER.info(f"Применена миграция {path.name}")
|
||||
finally:
|
||||
await conn.execute(
|
||||
"SELECT pg_advisory_unlock($1, 0);", MIGRATIONS_LOCK_NAMESPACE
|
||||
)
|
||||
LOGGER.info("Схема БД в актуальной версии")
|
||||
|
||||
async def check_migrations(self, directory: Path = MIGRATIONS_DIR) -> None:
|
||||
"""
|
||||
Схема БД не старше кода: все миграции из образа уже применены.
|
||||
|
||||
API миграции не применяет. Если migrate ещё не отработал, реплика не
|
||||
стартует и не начинает слушать порт, балансировщик её не использует
|
||||
|
||||
"""
|
||||
expected = {version for version, _ in self._migration_files(directory)}
|
||||
async with self.acquire() as conn:
|
||||
try:
|
||||
records = await conn.fetch("SELECT version FROM schema_migrations;")
|
||||
except asyncpg.UndefinedTableError:
|
||||
records = []
|
||||
applied = {record["version"] for record in records}
|
||||
missing = sorted(expected - applied)
|
||||
if missing:
|
||||
raise RuntimeError(
|
||||
f"В БД не применены миграции {missing}: сначала запустите migrate"
|
||||
)
|
||||
LOGGER.info(f"Схема БД совместима: версия {max(applied, default=0)}")
|
||||
|
||||
@staticmethod
|
||||
def _migration_files(directory: Path) -> list[tuple[int, Path]]:
|
||||
"""Файлы NNNN_name.sql по возрастанию версии"""
|
||||
return sorted(
|
||||
(int(path.name.split("_", 1)[0]), path) for path in directory.glob("*.sql")
|
||||
)
|
||||
|
||||
@asynccontextmanager
|
||||
async def acquire(self) -> AsyncIterator[asyncpg.Connection]:
|
||||
"""
|
||||
Получение соединения из пула с ограниченным ожиданием свободного.
|
||||
|
||||
После рестарта PostgreSQL все соединения пула мертвы. На первой же
|
||||
ошибке соединения пул помечает их на переподключение, чтобы 503
|
||||
получил один запрос, а не каждый из max_size следующих.
|
||||
"""
|
||||
assert self.pool is not None
|
||||
try:
|
||||
async with self.pool.acquire(timeout=self.connect_timeout) as connection:
|
||||
yield connection
|
||||
except BROKEN_CONNECTION_ERRORS:
|
||||
await self.pool.expire_connections()
|
||||
raise
|
||||
|
||||
async def check(self) -> bool:
|
||||
"""PostgreSQL отвечает на запрос — для readiness"""
|
||||
try:
|
||||
async with self.acquire() as conn:
|
||||
await conn.fetchval("SELECT 1;", timeout=self.connect_timeout)
|
||||
except DATABASE_UNAVAILABLE_ERRORS:
|
||||
return False
|
||||
return True
|
||||
|
||||
async def close(self) -> None:
|
||||
if self.pool:
|
||||
await self.pool.close()
|
||||
self.pool = None
|
||||
|
||||
|
||||
def get_database(connection: HTTPConnection) -> DatabasePoolManager:
|
||||
"""Получение менеджера пула соединений, созданного в lifespan."""
|
||||
database: DatabasePoolManager = connection.app.state.database
|
||||
return database
|
||||
|
||||
|
||||
database_pool_manager = DatabasePoolManager(
|
||||
user=DB_USER,
|
||||
password=DB_PASS,
|
||||
db=DB_NAME,
|
||||
host=DB_HOST,
|
||||
port=DB_PORT,
|
||||
min_size=DB_POOL_MIN_SIZE,
|
||||
max_size=DB_POOL_MAX_SIZE,
|
||||
connect_timeout=DB_CONNECT_TIMEOUT_SEC,
|
||||
command_timeout=DB_COMMAND_TIMEOUT_SEC,
|
||||
)
|
||||
@@ -0,0 +1,142 @@
|
||||
from fastapi import Depends
|
||||
|
||||
from config import (
|
||||
ATTACHMENT_PENDING_GRACE_SEC,
|
||||
ATTACHMENT_STORE_TIMEOUT_SEC,
|
||||
IDEMPOTENCY_TTL_SECONDS,
|
||||
MAX_UPLOAD_BYTES,
|
||||
SESSION_CACHE_TTL_SECONDS,
|
||||
SESSION_TTL_SECONDS,
|
||||
UPLOAD_SPOOL_MEMORY_BYTES,
|
||||
)
|
||||
from infrastructure.dependencies.cache import CacheManager, get_cache
|
||||
from infrastructure.dependencies.database import DatabasePoolManager, get_database
|
||||
from infrastructure.dependencies.storage import ObjectStorageManager, get_storage
|
||||
from infrastructure.media import ImageInspector, get_image_inspector
|
||||
from infrastructure.repositories import (
|
||||
PostgresAttachmentRepository,
|
||||
PostgresChatRepository,
|
||||
PostgresMessageRepository,
|
||||
PostgresSessionRepository,
|
||||
PostgresUserRepository,
|
||||
S3ObjectStorage,
|
||||
ValkeySessionCache,
|
||||
)
|
||||
from infrastructure.security import PasswordHasher, get_password_hasher
|
||||
from infrastructure.services import (
|
||||
AttachmentService,
|
||||
AuthService,
|
||||
ChatService,
|
||||
MessageService,
|
||||
UserService,
|
||||
)
|
||||
from interfaces import (
|
||||
AttachmentRepository,
|
||||
ChatRepository,
|
||||
MessageRepository,
|
||||
ObjectStorage,
|
||||
SessionCache,
|
||||
SessionRepository,
|
||||
UserRepository,
|
||||
)
|
||||
|
||||
|
||||
class ServiceCreator:
|
||||
@staticmethod
|
||||
def _get_user_repository(
|
||||
database: DatabasePoolManager = Depends(get_database),
|
||||
) -> UserRepository:
|
||||
return PostgresUserRepository(database)
|
||||
|
||||
@staticmethod
|
||||
def _get_chat_repository(
|
||||
database: DatabasePoolManager = Depends(get_database),
|
||||
) -> ChatRepository:
|
||||
return PostgresChatRepository(database)
|
||||
|
||||
@staticmethod
|
||||
def _get_message_repository(
|
||||
database: DatabasePoolManager = Depends(get_database),
|
||||
) -> MessageRepository:
|
||||
return PostgresMessageRepository(database)
|
||||
|
||||
@staticmethod
|
||||
def _get_session_repository(
|
||||
database: DatabasePoolManager = Depends(get_database),
|
||||
) -> SessionRepository:
|
||||
return PostgresSessionRepository(database)
|
||||
|
||||
@staticmethod
|
||||
def _get_attachment_repository(
|
||||
database: DatabasePoolManager = Depends(get_database),
|
||||
) -> AttachmentRepository:
|
||||
return PostgresAttachmentRepository(database)
|
||||
|
||||
@staticmethod
|
||||
def _get_object_storage(
|
||||
storage: ObjectStorageManager = Depends(get_storage),
|
||||
) -> ObjectStorage:
|
||||
return S3ObjectStorage(storage)
|
||||
|
||||
@staticmethod
|
||||
def _get_session_cache(
|
||||
cache: CacheManager = Depends(get_cache),
|
||||
) -> SessionCache:
|
||||
return ValkeySessionCache(cache, SESSION_CACHE_TTL_SECONDS)
|
||||
|
||||
@staticmethod
|
||||
def get_user_service(
|
||||
repository: UserRepository = Depends(_get_user_repository),
|
||||
hasher: PasswordHasher = Depends(get_password_hasher),
|
||||
) -> UserService:
|
||||
return UserService(repository, hasher)
|
||||
|
||||
@staticmethod
|
||||
def get_auth_service(
|
||||
user_repository: UserRepository = Depends(_get_user_repository),
|
||||
session_repository: SessionRepository = Depends(_get_session_repository),
|
||||
session_cache: SessionCache = Depends(_get_session_cache),
|
||||
hasher: PasswordHasher = Depends(get_password_hasher),
|
||||
) -> AuthService:
|
||||
return AuthService(
|
||||
user_repository,
|
||||
session_repository,
|
||||
session_cache,
|
||||
hasher,
|
||||
SESSION_TTL_SECONDS,
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def get_chat_service(
|
||||
chat_repository: ChatRepository = Depends(_get_chat_repository),
|
||||
) -> ChatService:
|
||||
return ChatService(chat_repository)
|
||||
|
||||
@staticmethod
|
||||
def get_message_service(
|
||||
chat_repository: ChatRepository = Depends(_get_chat_repository),
|
||||
message_repository: MessageRepository = Depends(_get_message_repository),
|
||||
) -> MessageService:
|
||||
return MessageService(
|
||||
chat_repository, message_repository, IDEMPOTENCY_TTL_SECONDS
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def get_attachment_service(
|
||||
chat_repository: ChatRepository = Depends(_get_chat_repository),
|
||||
attachment_repository: AttachmentRepository = Depends(
|
||||
_get_attachment_repository
|
||||
),
|
||||
storage: ObjectStorage = Depends(_get_object_storage),
|
||||
inspector: ImageInspector = Depends(get_image_inspector),
|
||||
) -> AttachmentService:
|
||||
return AttachmentService(
|
||||
chat_repository,
|
||||
attachment_repository,
|
||||
storage,
|
||||
inspector,
|
||||
MAX_UPLOAD_BYTES,
|
||||
UPLOAD_SPOOL_MEMORY_BYTES,
|
||||
ATTACHMENT_STORE_TIMEOUT_SEC,
|
||||
ATTACHMENT_PENDING_GRACE_SEC,
|
||||
)
|
||||
@@ -0,0 +1,187 @@
|
||||
import asyncio
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from contextlib import AsyncExitStack
|
||||
from pathlib import Path
|
||||
|
||||
from aiobotocore.client import AioBaseClient
|
||||
from aiobotocore.config import AioConfig
|
||||
from aiobotocore.session import get_session
|
||||
from botocore.exceptions import ClientError
|
||||
from starlette.requests import HTTPConnection
|
||||
|
||||
from config import (
|
||||
LOGGER,
|
||||
S3_ACCESS_KEY_ID_FILE,
|
||||
S3_BUCKET,
|
||||
S3_CONNECT_TIMEOUT_SEC,
|
||||
S3_ENDPOINT,
|
||||
S3_MAX_ATTEMPTS,
|
||||
S3_POOL_MAX_SIZE,
|
||||
S3_READ_TIMEOUT_SEC,
|
||||
S3_REGION,
|
||||
S3_SECRET_ACCESS_KEY_FILE,
|
||||
)
|
||||
from infrastructure.security import read_secret
|
||||
from infrastructure.utils import STORAGE_UNAVAILABLE_ERRORS, storage_error_code
|
||||
|
||||
STARTUP_RETRY_INTERVAL_SEC = 1
|
||||
|
||||
ANONYMOUS_CHECK_TIMEOUT_SEC = 3
|
||||
|
||||
# Ответ S3 на уже существующий bucket: повторный bootstrap — не ошибка
|
||||
BUCKET_EXISTS_CODES = frozenset({"BucketAlreadyOwnedByYou", "BucketAlreadyExists"})
|
||||
|
||||
|
||||
class ObjectStorageManager:
|
||||
"""
|
||||
Клиент S3 (aiobotocore): ограниченный пул соединений, короткие таймауты
|
||||
и ограниченное число попыток. Ключи доступа читаются из файлов-секретов
|
||||
при создании клиента и нигде не логируются.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
endpoint: str,
|
||||
region: str,
|
||||
bucket: str,
|
||||
access_key_file: Path,
|
||||
secret_key_file: Path,
|
||||
max_pool_size: int,
|
||||
connect_timeout: float,
|
||||
read_timeout: float,
|
||||
max_attempts: int,
|
||||
) -> None:
|
||||
self._endpoint = endpoint
|
||||
self._region = region
|
||||
self.bucket = bucket
|
||||
self._access_key_file = access_key_file
|
||||
self._secret_key_file = secret_key_file
|
||||
self.max_pool_size = max_pool_size
|
||||
self.connect_timeout = connect_timeout
|
||||
self.read_timeout = read_timeout
|
||||
self.max_attempts = max_attempts
|
||||
self.client: AioBaseClient | None = None
|
||||
self._exit_stack = AsyncExitStack()
|
||||
|
||||
async def create_client(self) -> AioBaseClient:
|
||||
"""
|
||||
Создание клиента; соединения открываются лениво при первом запросе.
|
||||
|
||||
Path-style адресация: имя bucket в пути, а не в DNS-имени хоста.
|
||||
Контрольные суммы botocore по умолчанию выключены (when_required):
|
||||
целостность PUT обеспечивает собственный SHA-256 (x-amz-checksum-sha256).
|
||||
"""
|
||||
if self.client is None:
|
||||
config = AioConfig(
|
||||
s3={"addressing_style": "path"},
|
||||
connect_timeout=self.connect_timeout,
|
||||
read_timeout=self.read_timeout,
|
||||
retries={"max_attempts": self.max_attempts, "mode": "standard"},
|
||||
max_pool_connections=self.max_pool_size,
|
||||
request_checksum_calculation="when_required",
|
||||
response_checksum_validation="when_required",
|
||||
)
|
||||
client = get_session().create_client(
|
||||
"s3",
|
||||
endpoint_url=self._endpoint,
|
||||
region_name=self._region,
|
||||
aws_access_key_id=read_secret(self._access_key_file),
|
||||
aws_secret_access_key=read_secret(self._secret_key_file),
|
||||
config=config,
|
||||
)
|
||||
self.client = await self._exit_stack.enter_async_context(client)
|
||||
LOGGER.info(
|
||||
f"Клиент S3 создан: {self._endpoint}, bucket: {self.bucket}, "
|
||||
f"pool: {self.max_pool_size}, timeout: {self.connect_timeout}/"
|
||||
f"{self.read_timeout} с, попыток: {self.max_attempts}"
|
||||
)
|
||||
return self.client
|
||||
|
||||
async def check(self) -> bool:
|
||||
"""
|
||||
Bucket доступен с текущими ключами — для readiness. Срок ограничен
|
||||
connect_timeout: healthcheck не ждёт всех попыток клиента.
|
||||
Не журналирует: readiness опрашивается каждые несколько секунд.
|
||||
"""
|
||||
assert self.client is not None
|
||||
try:
|
||||
async with asyncio.timeout(self.connect_timeout):
|
||||
await self.client.head_bucket(Bucket=self.bucket)
|
||||
except STORAGE_UNAVAILABLE_ERRORS:
|
||||
return False
|
||||
return True
|
||||
|
||||
async def wait_ready(self, startup_timeout: float) -> None:
|
||||
"""Ожидание S3 при старте стенда: сервер поднимается не мгновенно"""
|
||||
assert self.client is not None
|
||||
deadline = time.monotonic() + startup_timeout
|
||||
while True:
|
||||
try:
|
||||
await self.client.list_buckets()
|
||||
return
|
||||
except STORAGE_UNAVAILABLE_ERRORS as error:
|
||||
if time.monotonic() >= deadline:
|
||||
LOGGER.error(
|
||||
f"S3 недоступен за {startup_timeout} с: "
|
||||
f"{storage_error_code(error)}"
|
||||
)
|
||||
raise
|
||||
LOGGER.warning(f"S3 ещё недоступен: {storage_error_code(error)}, повтор")
|
||||
await asyncio.sleep(STARTUP_RETRY_INTERVAL_SEC)
|
||||
|
||||
async def ensure_bucket(self) -> None:
|
||||
"""
|
||||
Идемпотентное создание bucket административными ключами (s3-bootstrap).
|
||||
Повторный запуск ничего не меняет.
|
||||
"""
|
||||
assert self.client is not None
|
||||
try:
|
||||
await self.client.create_bucket(Bucket=self.bucket)
|
||||
LOGGER.info(f"Bucket {self.bucket} создан")
|
||||
except ClientError as error:
|
||||
if storage_error_code(error) not in BUCKET_EXISTS_CODES:
|
||||
raise
|
||||
LOGGER.info(f"Bucket {self.bucket} уже существует")
|
||||
|
||||
def check_anonymous_denied(self) -> None:
|
||||
"""
|
||||
Bucket приватен: анонимный (неподписанный) запрос списка объектов
|
||||
получает 403. Иначе bootstrap завершается ошибкой и API не стартует.
|
||||
"""
|
||||
url = f"{self._endpoint.rstrip('/')}/{self.bucket}"
|
||||
try:
|
||||
with urllib.request.urlopen(url, timeout=ANONYMOUS_CHECK_TIMEOUT_SEC):
|
||||
pass
|
||||
except urllib.error.HTTPError as error:
|
||||
if error.code == 403:
|
||||
LOGGER.info(f"Bucket {self.bucket} приватен: анонимный доступ — 403")
|
||||
return
|
||||
raise RuntimeError(
|
||||
f"Неожиданный ответ на анонимный запрос к bucket: {error.code}"
|
||||
) from None
|
||||
raise RuntimeError(f"Bucket {self.bucket} доступен анонимно")
|
||||
|
||||
async def close(self) -> None:
|
||||
await self._exit_stack.aclose()
|
||||
self.client = None
|
||||
|
||||
|
||||
def get_storage(connection: HTTPConnection) -> ObjectStorageManager:
|
||||
"""Получение менеджера S3-клиента, созданного в lifespan."""
|
||||
storage: ObjectStorageManager = connection.app.state.storage
|
||||
return storage
|
||||
|
||||
|
||||
storage_manager = ObjectStorageManager(
|
||||
endpoint=S3_ENDPOINT,
|
||||
region=S3_REGION,
|
||||
bucket=S3_BUCKET,
|
||||
access_key_file=S3_ACCESS_KEY_ID_FILE,
|
||||
secret_key_file=S3_SECRET_ACCESS_KEY_FILE,
|
||||
max_pool_size=S3_POOL_MAX_SIZE,
|
||||
connect_timeout=S3_CONNECT_TIMEOUT_SEC,
|
||||
read_timeout=S3_READ_TIMEOUT_SEC,
|
||||
max_attempts=S3_MAX_ATTEMPTS,
|
||||
)
|
||||
@@ -0,0 +1,4 @@
|
||||
from .image_inspector import ImageInspector, get_image_inspector
|
||||
from .upload_spool import SpooledUpload, spool_upload
|
||||
|
||||
__all__ = ["ImageInspector", "get_image_inspector", "SpooledUpload", "spool_upload"]
|
||||
@@ -0,0 +1,127 @@
|
||||
import asyncio
|
||||
import struct
|
||||
import warnings
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from typing import IO
|
||||
|
||||
from PIL import Image, UnidentifiedImageError
|
||||
from starlette.requests import HTTPConnection
|
||||
|
||||
from domain import AttachmentContentType, InspectedImageSchema
|
||||
from domain.errors import PayloadTooLargeError, UnsupportedMediaTypeError
|
||||
|
||||
PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
|
||||
JPEG_SIGNATURE = b"\xff\xd8\xff"
|
||||
|
||||
PILLOW_FORMATS = {
|
||||
AttachmentContentType.PNG: "PNG",
|
||||
AttachmentContentType.JPEG: "JPEG",
|
||||
}
|
||||
|
||||
# Как Pillow сообщает о повреждённом или чужом содержимом
|
||||
DECODE_ERRORS: tuple[type[Exception], ...] = (
|
||||
UnidentifiedImageError,
|
||||
OSError,
|
||||
SyntaxError,
|
||||
ValueError,
|
||||
EOFError,
|
||||
struct.error,
|
||||
)
|
||||
|
||||
|
||||
class ImageInspector:
|
||||
"""
|
||||
Проверка PNG/JPEG по содержимому, а не по Content-Type клиента.
|
||||
|
||||
1. Формат — по сигнатуре; несовпадение с заявленным Content-Type — 415.
|
||||
2. Ширина и высота читаются из заголовка, лимит пикселей проверяется до
|
||||
распаковки: 413 без выделения памяти под изображение.
|
||||
3. Целостность: PNG — CRC каждого chunk и наличие IEND (verify, без
|
||||
распаковки); JPEG — декодирование в draft-режиме libjpeg (масштаб 1/8).
|
||||
|
||||
Проверка идёт в отдельном пуле потоков: event loop не блокируется, а число
|
||||
одновременных декодирований и их память ограничены workers. Худший случай —
|
||||
progressive JPEG на пределе пикселей: libjpeg держит коэффициенты всего
|
||||
изображения (до ~6 байт на пиксель) даже в draft-режиме.
|
||||
"""
|
||||
|
||||
def __init__(self, workers: int, max_pixels: int) -> None:
|
||||
self._max_pixels = max_pixels
|
||||
# Вторая линия защиты Pillow: Image.open отказывает выше 2 * max_pixels.
|
||||
# Предупреждение в диапазоне (max, 2 * max] не нужно: такой файл
|
||||
# отклоняется явной проверкой ниже.
|
||||
Image.MAX_IMAGE_PIXELS = max_pixels
|
||||
warnings.simplefilter("ignore", Image.DecompressionBombWarning)
|
||||
self._executor = ThreadPoolExecutor(
|
||||
max_workers=workers, thread_name_prefix="image-inspect"
|
||||
)
|
||||
|
||||
async def inspect(
|
||||
self, file: IO[bytes], declared: AttachmentContentType
|
||||
) -> InspectedImageSchema:
|
||||
"""
|
||||
Raises:
|
||||
UnsupportedMediaTypeError: не PNG/JPEG, повреждено или подмена MIME
|
||||
PayloadTooLargeError: пикселей больше лимита
|
||||
"""
|
||||
loop = asyncio.get_running_loop()
|
||||
return await loop.run_in_executor(
|
||||
self._executor, self._inspect, file, declared
|
||||
)
|
||||
|
||||
def close(self) -> None:
|
||||
self._executor.shutdown(wait=False, cancel_futures=True)
|
||||
|
||||
def _inspect(
|
||||
self, file: IO[bytes], declared: AttachmentContentType
|
||||
) -> InspectedImageSchema:
|
||||
file.seek(0)
|
||||
actual = self._sniff(file.read(len(PNG_SIGNATURE)))
|
||||
if actual is None:
|
||||
raise UnsupportedMediaTypeError(
|
||||
"Содержимое не является изображением PNG или JPEG"
|
||||
)
|
||||
if actual is not declared:
|
||||
raise UnsupportedMediaTypeError(
|
||||
"Content-Type не соответствует содержимому файла"
|
||||
)
|
||||
file.seek(0)
|
||||
try:
|
||||
with Image.open(file, formats=[PILLOW_FORMATS[actual]]) as image:
|
||||
width, height = image.size
|
||||
if width * height > self._max_pixels:
|
||||
raise PayloadTooLargeError(
|
||||
f"Изображение больше {self._max_pixels} пикселей"
|
||||
)
|
||||
self._verify(image, actual)
|
||||
except Image.DecompressionBombError:
|
||||
raise PayloadTooLargeError(
|
||||
f"Изображение больше {self._max_pixels} пикселей"
|
||||
) from None
|
||||
except DECODE_ERRORS:
|
||||
raise UnsupportedMediaTypeError("Изображение повреждено") from None
|
||||
return InspectedImageSchema(content_type=actual, width=width, height=height)
|
||||
|
||||
@staticmethod
|
||||
def _sniff(header: bytes) -> AttachmentContentType | None:
|
||||
if header.startswith(PNG_SIGNATURE):
|
||||
return AttachmentContentType.PNG
|
||||
if header.startswith(JPEG_SIGNATURE):
|
||||
return AttachmentContentType.JPEG
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def _verify(image: Image.Image, content_type: AttachmentContentType) -> None:
|
||||
if content_type is AttachmentContentType.PNG:
|
||||
image.verify()
|
||||
return
|
||||
# draft выбирает наименьший масштаб libjpeg (1/8): весь поток данных
|
||||
# разбирается, но выходной буфер в 64 раза меньше полного
|
||||
image.draft(image.mode, (1, 1))
|
||||
image.load()
|
||||
|
||||
|
||||
def get_image_inspector(connection: HTTPConnection) -> ImageInspector:
|
||||
"""Получение проверки изображений, созданной в lifespan."""
|
||||
inspector: ImageInspector = connection.app.state.image_inspector
|
||||
return inspector
|
||||
@@ -0,0 +1,49 @@
|
||||
import hashlib
|
||||
import tempfile
|
||||
from collections.abc import AsyncIterator
|
||||
from contextlib import asynccontextmanager
|
||||
from dataclasses import dataclass
|
||||
from typing import IO
|
||||
|
||||
from domain.errors import InvalidRequestError, PayloadTooLargeError
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class SpooledUpload:
|
||||
"""Принятое тело загрузки: файл запроса, размер и SHA-256 байт"""
|
||||
|
||||
file: IO[bytes]
|
||||
size: int
|
||||
sha256: bytes
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def spool_upload(
|
||||
chunks: AsyncIterator[bytes], max_bytes: int, memory_bytes: int
|
||||
) -> AsyncIterator[SpooledUpload]:
|
||||
"""
|
||||
Приём тела потоком: первые memory_bytes держатся в RAM, остальное —
|
||||
во временном файле запроса, который удаляется при выходе из контекста
|
||||
(в том числе при обрыве загрузки). Это не хранилище: оригинал живёт в S3.
|
||||
|
||||
Чтение прекращается на первом байте сверх max_bytes, поэтому одна загрузка
|
||||
занимает не больше memory_bytes RAM и max_bytes диска. SHA-256 и размер
|
||||
считаются по ходу чтения, без второго прохода.
|
||||
|
||||
Raises:
|
||||
PayloadTooLargeError: тело больше max_bytes
|
||||
InvalidRequestError: пустое тело
|
||||
"""
|
||||
with tempfile.SpooledTemporaryFile(max_size=memory_bytes) as file:
|
||||
digest = hashlib.sha256()
|
||||
size = 0
|
||||
async for chunk in chunks:
|
||||
size += len(chunk)
|
||||
if size > max_bytes:
|
||||
raise PayloadTooLargeError(f"Файл больше {max_bytes} байт")
|
||||
digest.update(chunk)
|
||||
file.write(chunk)
|
||||
if size == 0:
|
||||
raise InvalidRequestError("Пустое тело: ожидаются байты PNG или JPEG")
|
||||
file.seek(0)
|
||||
yield SpooledUpload(file=file, size=size, sha256=digest.digest())
|
||||
@@ -0,0 +1,17 @@
|
||||
from .attachment_repository import PostgresAttachmentRepository
|
||||
from .chat_repository import PostgresChatRepository
|
||||
from .message_repository import PostgresMessageRepository
|
||||
from .object_storage import S3ObjectStorage
|
||||
from .session_cache import ValkeySessionCache
|
||||
from .session_repository import PostgresSessionRepository
|
||||
from .user_repository import PostgresUserRepository
|
||||
|
||||
__all__ = [
|
||||
"PostgresUserRepository",
|
||||
"PostgresChatRepository",
|
||||
"PostgresMessageRepository",
|
||||
"PostgresSessionRepository",
|
||||
"PostgresAttachmentRepository",
|
||||
"ValkeySessionCache",
|
||||
"S3ObjectStorage",
|
||||
]
|
||||
@@ -0,0 +1,3 @@
|
||||
from .postgres import PostgresAttachmentRepository
|
||||
|
||||
__all__ = ["PostgresAttachmentRepository"]
|
||||
@@ -0,0 +1,281 @@
|
||||
from uuid import UUID
|
||||
|
||||
import asyncpg
|
||||
|
||||
from domain import (
|
||||
AttachmentSchema,
|
||||
AttachmentStatus,
|
||||
NewAttachmentSchema,
|
||||
StoredAttachmentSchema,
|
||||
UnfinishedUploadSchema,
|
||||
)
|
||||
from domain.errors import NotFoundError
|
||||
from infrastructure.utils import Pool, repository_logs
|
||||
from interfaces import AttachmentRepository
|
||||
|
||||
|
||||
class PostgresAttachmentRepository(AttachmentRepository):
|
||||
def __init__(self, pool: Pool) -> None:
|
||||
self._pool = pool
|
||||
|
||||
@repository_logs
|
||||
async def create_pending(self, attachment: NewAttachmentSchema) -> UUID:
|
||||
"""
|
||||
Строка коммитится до PUT в S3. Владелец обязан быть участником чата —
|
||||
это проверяет FK на chat_members.
|
||||
"""
|
||||
query = """
|
||||
INSERT INTO attachments
|
||||
(
|
||||
chat_id,
|
||||
owner_id,
|
||||
filename,
|
||||
content_type,
|
||||
size_bytes,
|
||||
sha256,
|
||||
object_key,
|
||||
status
|
||||
)
|
||||
VALUES
|
||||
(
|
||||
$1,
|
||||
$2,
|
||||
$3,
|
||||
$4,
|
||||
$5,
|
||||
$6,
|
||||
$7,
|
||||
$8
|
||||
)
|
||||
RETURNING id;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
try:
|
||||
attachment_id: UUID = await conn.fetchval(
|
||||
query,
|
||||
attachment.chat_id,
|
||||
attachment.owner_id,
|
||||
attachment.filename,
|
||||
attachment.content_type,
|
||||
attachment.size_bytes,
|
||||
attachment.sha256,
|
||||
attachment.object_key,
|
||||
AttachmentStatus.PENDING,
|
||||
)
|
||||
except asyncpg.ForeignKeyViolationError:
|
||||
raise NotFoundError() from None
|
||||
return attachment_id
|
||||
|
||||
@repository_logs
|
||||
async def mark_ready(
|
||||
self, attachment_id: UUID, grace_seconds: int
|
||||
) -> AttachmentSchema | None:
|
||||
"""
|
||||
Условие по возрасту на часах БД — тех же, по которым janitor отбирает
|
||||
строки: загрузка, которую janitor уже может очищать, не подтверждается.
|
||||
Одновременный claim janitor и это UPDATE сериализует блокировка строки.
|
||||
"""
|
||||
query = """
|
||||
UPDATE attachments
|
||||
SET
|
||||
status = $2,
|
||||
updated_at = clock_timestamp()
|
||||
WHERE
|
||||
id = $1
|
||||
AND status = $3
|
||||
AND created_at > clock_timestamp() - make_interval(secs => $4::integer)
|
||||
RETURNING
|
||||
id,
|
||||
chat_id,
|
||||
owner_id,
|
||||
filename,
|
||||
content_type,
|
||||
size_bytes,
|
||||
sha256,
|
||||
created_at,
|
||||
updated_at;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
query,
|
||||
attachment_id,
|
||||
AttachmentStatus.READY,
|
||||
AttachmentStatus.PENDING,
|
||||
grace_seconds,
|
||||
)
|
||||
return self._row_to_attachment(row) if row is not None else None
|
||||
|
||||
@repository_logs
|
||||
async def claim_pending(self, attachment_id: UUID) -> UnfinishedUploadSchema | None:
|
||||
query = """
|
||||
UPDATE attachments
|
||||
SET
|
||||
status = $2,
|
||||
updated_at = clock_timestamp()
|
||||
WHERE
|
||||
id = $1
|
||||
AND status = $3
|
||||
RETURNING id, object_key;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
query,
|
||||
attachment_id,
|
||||
AttachmentStatus.DELETING,
|
||||
AttachmentStatus.PENDING,
|
||||
)
|
||||
return self._row_to_unfinished(row) if row is not None else None
|
||||
|
||||
@repository_logs
|
||||
async def claim_unfinished(
|
||||
self, grace_seconds: int, limit: int
|
||||
) -> list[UnfinishedUploadSchema]:
|
||||
"""
|
||||
Перевод pending → deleting атомарен: после него mark_ready этой строки
|
||||
невозможен. SKIP LOCKED — строку, которую сейчас подтверждает API,
|
||||
janitor не ждёт и не забирает. deleting-строки возвращаются независимо
|
||||
от возраста: их очистка прервалась и повторяется.
|
||||
"""
|
||||
query = """
|
||||
WITH stale AS
|
||||
(
|
||||
SELECT id
|
||||
FROM attachments
|
||||
WHERE
|
||||
status IN ($2, $3)
|
||||
AND
|
||||
(
|
||||
status = $3
|
||||
OR created_at < clock_timestamp() - make_interval(secs => $1::integer)
|
||||
)
|
||||
ORDER BY created_at
|
||||
LIMIT $4
|
||||
FOR UPDATE SKIP LOCKED
|
||||
)
|
||||
UPDATE attachments attachment
|
||||
SET
|
||||
status = $3,
|
||||
updated_at = clock_timestamp()
|
||||
FROM stale
|
||||
WHERE attachment.id = stale.id
|
||||
RETURNING attachment.id, attachment.object_key;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
rows = await conn.fetch(
|
||||
query,
|
||||
grace_seconds,
|
||||
AttachmentStatus.PENDING,
|
||||
AttachmentStatus.DELETING,
|
||||
limit,
|
||||
)
|
||||
return [self._row_to_unfinished(row) for row in rows]
|
||||
|
||||
@repository_logs
|
||||
async def list_unfinished(
|
||||
self, grace_seconds: int, limit: int
|
||||
) -> list[UnfinishedUploadSchema]:
|
||||
query = """
|
||||
SELECT
|
||||
id,
|
||||
object_key
|
||||
FROM attachments
|
||||
WHERE
|
||||
status IN ($2, $3)
|
||||
AND
|
||||
(
|
||||
status = $3
|
||||
OR created_at < clock_timestamp() - make_interval(secs => $1::integer)
|
||||
)
|
||||
ORDER BY created_at
|
||||
LIMIT $4;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
rows = await conn.fetch(
|
||||
query,
|
||||
grace_seconds,
|
||||
AttachmentStatus.PENDING,
|
||||
AttachmentStatus.DELETING,
|
||||
limit,
|
||||
)
|
||||
return [self._row_to_unfinished(row) for row in rows]
|
||||
|
||||
@repository_logs
|
||||
async def delete_claimed(self, attachment_ids: list[UUID]) -> int:
|
||||
query = """
|
||||
DELETE FROM attachments
|
||||
WHERE
|
||||
id = ANY($1::uuid[])
|
||||
AND status = $2;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
status = await conn.execute(
|
||||
query, attachment_ids, AttachmentStatus.DELETING
|
||||
)
|
||||
return int(status.split()[-1])
|
||||
|
||||
@repository_logs
|
||||
async def get_for_member(
|
||||
self, attachment_id: UUID, member_id: UUID
|
||||
) -> StoredAttachmentSchema | None:
|
||||
query = """
|
||||
SELECT
|
||||
attachment.id,
|
||||
attachment.chat_id,
|
||||
attachment.owner_id,
|
||||
attachment.filename,
|
||||
attachment.content_type,
|
||||
attachment.size_bytes,
|
||||
attachment.sha256,
|
||||
attachment.object_key,
|
||||
attachment.created_at,
|
||||
attachment.updated_at
|
||||
FROM attachments attachment
|
||||
WHERE
|
||||
attachment.id = $1
|
||||
AND attachment.status = $3
|
||||
AND EXISTS
|
||||
(
|
||||
SELECT 1
|
||||
FROM chat_members caller
|
||||
WHERE caller.chat_id = attachment.chat_id AND caller.user_id = $2
|
||||
);
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
query, attachment_id, member_id, AttachmentStatus.READY
|
||||
)
|
||||
if row is None:
|
||||
return None
|
||||
return StoredAttachmentSchema(
|
||||
attachment=self._row_to_attachment(row), object_key=row["object_key"]
|
||||
)
|
||||
|
||||
@repository_logs
|
||||
async def find_known_keys(self, object_keys: list[str]) -> set[str]:
|
||||
"""Поиск по уникальному индексу object_key"""
|
||||
query = """
|
||||
SELECT object_key
|
||||
FROM attachments
|
||||
WHERE object_key = ANY($1::text[]);
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
rows = await conn.fetch(query, object_keys)
|
||||
return {row["object_key"] for row in rows}
|
||||
|
||||
@staticmethod
|
||||
def _row_to_attachment(row: asyncpg.Record) -> AttachmentSchema:
|
||||
return AttachmentSchema(
|
||||
id=row["id"],
|
||||
chat_id=row["chat_id"],
|
||||
owner_id=row["owner_id"],
|
||||
filename=row["filename"],
|
||||
content_type=row["content_type"],
|
||||
size_bytes=row["size_bytes"],
|
||||
sha256=row["sha256"].hex(),
|
||||
created_at=row["created_at"],
|
||||
updated_at=row["updated_at"],
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _row_to_unfinished(row: asyncpg.Record) -> UnfinishedUploadSchema:
|
||||
return UnfinishedUploadSchema(id=row["id"], object_key=row["object_key"])
|
||||
@@ -0,0 +1,3 @@
|
||||
from .postgres import PostgresChatRepository
|
||||
|
||||
__all__ = ["PostgresChatRepository"]
|
||||
@@ -0,0 +1,150 @@
|
||||
from uuid import UUID
|
||||
|
||||
import asyncpg
|
||||
|
||||
from domain import ChatSchema, PageKey
|
||||
from domain.errors import InvalidRequestError
|
||||
from infrastructure.utils import Pool, repository_logs, transaction
|
||||
from interfaces import ChatRepository
|
||||
|
||||
|
||||
class PostgresChatRepository(ChatRepository):
|
||||
def __init__(self, pool: Pool) -> None:
|
||||
self._pool = pool
|
||||
|
||||
@repository_logs
|
||||
async def create(
|
||||
self, title: str, created_by: UUID, member_ids: list[UUID]
|
||||
) -> ChatSchema:
|
||||
"""
|
||||
Чат и участники — одна транзакция. Неизвестный участник нарушает FK
|
||||
на users, транзакция откатывается целиком, строка chats не остаётся.
|
||||
Участники вставляются одним запросом; position — порядок в member_ids.
|
||||
"""
|
||||
chat_query = """
|
||||
INSERT INTO chats
|
||||
(
|
||||
title,
|
||||
created_by
|
||||
)
|
||||
VALUES
|
||||
(
|
||||
$1,
|
||||
$2
|
||||
)
|
||||
RETURNING id, title, created_at;
|
||||
"""
|
||||
members_query = """
|
||||
INSERT INTO chat_members
|
||||
(
|
||||
chat_id,
|
||||
user_id,
|
||||
position
|
||||
)
|
||||
SELECT
|
||||
$1,
|
||||
member.user_id,
|
||||
member.ordinality - 1
|
||||
FROM unnest($2::uuid[]) WITH ORDINALITY AS member(user_id, ordinality);
|
||||
"""
|
||||
try:
|
||||
async with transaction(self._pool) as conn:
|
||||
row = await conn.fetchrow(chat_query, title, created_by)
|
||||
assert row is not None
|
||||
await conn.execute(members_query, row["id"], member_ids)
|
||||
except asyncpg.ForeignKeyViolationError:
|
||||
raise InvalidRequestError(
|
||||
"member_ids содержит неизвестных пользователей"
|
||||
) from None
|
||||
return ChatSchema(
|
||||
id=row["id"],
|
||||
title=row["title"],
|
||||
member_ids=member_ids,
|
||||
created_at=row["created_at"],
|
||||
)
|
||||
|
||||
@repository_logs
|
||||
async def get_for_member(self, chat_id: UUID, member_id: UUID) -> ChatSchema | None:
|
||||
query = """
|
||||
SELECT
|
||||
chat.id,
|
||||
chat.title,
|
||||
chat.created_at,
|
||||
ARRAY(
|
||||
SELECT member.user_id
|
||||
FROM chat_members member
|
||||
WHERE member.chat_id = chat.id
|
||||
ORDER BY member.position
|
||||
) AS member_ids
|
||||
FROM chats chat
|
||||
WHERE
|
||||
chat.id = $1
|
||||
AND EXISTS
|
||||
(
|
||||
SELECT 1
|
||||
FROM chat_members caller
|
||||
WHERE caller.chat_id = chat.id AND caller.user_id = $2
|
||||
);
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
row = await conn.fetchrow(query, chat_id, member_id)
|
||||
return self._row_to_chat(row) if row is not None else None
|
||||
|
||||
@repository_logs
|
||||
async def list_for_member(
|
||||
self, member_id: UUID, after: PageKey | None, limit: int
|
||||
) -> list[ChatSchema]:
|
||||
"""Чаты пользователя по (created_at, id); со второй страницы — после ключа"""
|
||||
first_page_query = """
|
||||
SELECT
|
||||
chat.id,
|
||||
chat.title,
|
||||
chat.created_at,
|
||||
ARRAY(
|
||||
SELECT member.user_id
|
||||
FROM chat_members member
|
||||
WHERE member.chat_id = chat.id
|
||||
ORDER BY member.position
|
||||
) AS member_ids
|
||||
FROM chat_members caller
|
||||
JOIN chats chat ON chat.id = caller.chat_id
|
||||
WHERE caller.user_id = $1
|
||||
ORDER BY chat.created_at, chat.id
|
||||
LIMIT $2;
|
||||
"""
|
||||
next_page_query = """
|
||||
SELECT
|
||||
chat.id,
|
||||
chat.title,
|
||||
chat.created_at,
|
||||
ARRAY(
|
||||
SELECT member.user_id
|
||||
FROM chat_members member
|
||||
WHERE member.chat_id = chat.id
|
||||
ORDER BY member.position
|
||||
) AS member_ids
|
||||
FROM chat_members caller
|
||||
JOIN chats chat ON chat.id = caller.chat_id
|
||||
WHERE
|
||||
caller.user_id = $1
|
||||
AND (chat.created_at, chat.id) > ($2, $3)
|
||||
ORDER BY chat.created_at, chat.id
|
||||
LIMIT $4;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
if after is None:
|
||||
rows = await conn.fetch(first_page_query, member_id, limit)
|
||||
else:
|
||||
rows = await conn.fetch(
|
||||
next_page_query, member_id, after.created_at, after.id, limit
|
||||
)
|
||||
return [self._row_to_chat(row) for row in rows]
|
||||
|
||||
@staticmethod
|
||||
def _row_to_chat(row: asyncpg.Record) -> ChatSchema:
|
||||
return ChatSchema(
|
||||
id=row["id"],
|
||||
title=row["title"],
|
||||
member_ids=row["member_ids"],
|
||||
created_at=row["created_at"],
|
||||
)
|
||||
@@ -0,0 +1,3 @@
|
||||
from .postgres import PostgresMessageRepository
|
||||
|
||||
__all__ = ["PostgresMessageRepository"]
|
||||
@@ -0,0 +1,229 @@
|
||||
from uuid import UUID
|
||||
|
||||
import asyncpg
|
||||
|
||||
from domain import IdempotencyKeySchema, MessageSchema, PageKey
|
||||
from domain.errors import ConflictError, NotFoundError
|
||||
from infrastructure.utils import Pool, repository_logs, transaction
|
||||
from interfaces import MessageRepository
|
||||
|
||||
# Пространство ключей advisory lock: (namespace, hashtext(chat_id))
|
||||
CHAT_LOCK_NAMESPACE = 2
|
||||
|
||||
# Вложения сообщения в порядке attachment_ids запроса
|
||||
MESSAGE_ATTACHMENT_IDS = """
|
||||
ARRAY(
|
||||
SELECT link.attachment_id
|
||||
FROM message_attachments link
|
||||
WHERE link.message_id = message.id
|
||||
ORDER BY link.position
|
||||
) AS attachment_ids
|
||||
"""
|
||||
|
||||
|
||||
class PostgresMessageRepository(MessageRepository):
|
||||
def __init__(self, pool: Pool) -> None:
|
||||
self._pool = pool
|
||||
|
||||
@repository_logs
|
||||
async def create(
|
||||
self,
|
||||
chat_id: UUID,
|
||||
sender_id: UUID,
|
||||
text: str,
|
||||
attachment_ids: list[UUID],
|
||||
idempotency: IdempotencyKeySchema,
|
||||
) -> tuple[MessageSchema, bool]:
|
||||
"""
|
||||
Блокировка чата, проверка ключа, вставка сообщения и ключа — одна
|
||||
транзакция; lock снимается на COMMIT.
|
||||
|
||||
Запись в один чат сериализуется, записи в разные чаты не мешают друг другу.
|
||||
Ключ идемпотентности привязан к чату, поэтому та же блокировка
|
||||
сериализует и одновременные повторы с одним ключом с разных реплик:
|
||||
второй ждёт COMMIT первого и находит его ключ
|
||||
|
||||
created_at строго больше последнего в чате, даже если часы ушли назад:
|
||||
порядок коммитов совпадает с порядком (created_at, id), и читатель
|
||||
с cursor не пропустит сообщение. MAX берётся из индекса
|
||||
(chat_id, created_at, id) — Index Only Scan Backward, а не проход по истории.
|
||||
|
||||
Вложения связываются одним INSERT ... SELECT только с готовыми
|
||||
вложениями этого чата; если связано меньше, чем передано, — 404
|
||||
и откат всей транзакции, сообщение не появляется. Составной FK
|
||||
(attachment_id, chat_id) дублирует проверку чата на уровне БД.
|
||||
"""
|
||||
lock_query = """
|
||||
SELECT pg_advisory_xact_lock($1, hashtext($2::uuid::text));
|
||||
"""
|
||||
find_key_query = f"""
|
||||
SELECT
|
||||
idem.request_hash,
|
||||
message.id,
|
||||
message.chat_id,
|
||||
message.sender_id,
|
||||
message.text,
|
||||
message.created_at,
|
||||
{MESSAGE_ATTACHMENT_IDS}
|
||||
FROM message_idempotency_keys idem
|
||||
JOIN messages message ON message.id = idem.message_id
|
||||
WHERE
|
||||
idem.sender_id = $1
|
||||
AND idem.chat_id = $2
|
||||
AND idem.idempotency_key = $3
|
||||
AND idem.expires_at > clock_timestamp();
|
||||
"""
|
||||
insert_query = """
|
||||
INSERT INTO messages
|
||||
(
|
||||
chat_id,
|
||||
sender_id,
|
||||
text,
|
||||
created_at
|
||||
)
|
||||
SELECT
|
||||
$1,
|
||||
$2,
|
||||
$3,
|
||||
GREATEST(clock_timestamp(), MAX(created_at) + interval '1 microsecond')
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
RETURNING id, chat_id, sender_id, text, created_at;
|
||||
"""
|
||||
attachments_query = """
|
||||
INSERT INTO message_attachments
|
||||
(
|
||||
message_id,
|
||||
chat_id,
|
||||
attachment_id,
|
||||
position
|
||||
)
|
||||
SELECT
|
||||
$1,
|
||||
$2,
|
||||
attachment.id,
|
||||
item.ordinality - 1
|
||||
FROM unnest($3::uuid[]) WITH ORDINALITY AS item(attachment_id, ordinality)
|
||||
JOIN attachments attachment
|
||||
ON attachment.id = item.attachment_id
|
||||
AND attachment.chat_id = $2
|
||||
AND attachment.status = 'ready';
|
||||
"""
|
||||
|
||||
save_key_query = """
|
||||
INSERT INTO message_idempotency_keys
|
||||
(
|
||||
sender_id,
|
||||
chat_id,
|
||||
idempotency_key,
|
||||
request_hash,
|
||||
message_id,
|
||||
expires_at
|
||||
)
|
||||
VALUES
|
||||
(
|
||||
$1,
|
||||
$2,
|
||||
$3,
|
||||
$4,
|
||||
$5,
|
||||
clock_timestamp() + make_interval(secs => $6::integer)
|
||||
)
|
||||
ON CONFLICT (sender_id, chat_id, idempotency_key) DO UPDATE
|
||||
SET
|
||||
request_hash = EXCLUDED.request_hash,
|
||||
message_id = EXCLUDED.message_id,
|
||||
created_at = EXCLUDED.created_at,
|
||||
expires_at = EXCLUDED.expires_at;
|
||||
"""
|
||||
async with transaction(self._pool) as conn:
|
||||
await conn.execute(lock_query, CHAT_LOCK_NAMESPACE, chat_id)
|
||||
stored = await conn.fetchrow(
|
||||
find_key_query, sender_id, chat_id, idempotency.key
|
||||
)
|
||||
if stored is not None:
|
||||
if stored["request_hash"] != idempotency.request_hash:
|
||||
raise ConflictError(
|
||||
"Idempotency-Key уже использован с другим телом запроса"
|
||||
)
|
||||
return self._row_to_message(stored), False
|
||||
row = await conn.fetchrow(insert_query, chat_id, sender_id, text)
|
||||
assert row is not None
|
||||
if attachment_ids:
|
||||
status = await conn.execute(
|
||||
attachments_query, row["id"], chat_id, attachment_ids
|
||||
)
|
||||
if int(status.split()[-1]) != len(attachment_ids):
|
||||
raise NotFoundError("Вложение не найдено")
|
||||
await conn.execute(
|
||||
save_key_query,
|
||||
sender_id,
|
||||
chat_id,
|
||||
idempotency.key,
|
||||
idempotency.request_hash,
|
||||
row["id"],
|
||||
idempotency.ttl_seconds,
|
||||
)
|
||||
return self._row_to_message(row, attachment_ids), True
|
||||
|
||||
@repository_logs
|
||||
async def list_for_chat(
|
||||
self, chat_id: UUID, after: PageKey | None, limit: int
|
||||
) -> list[MessageSchema]:
|
||||
"""
|
||||
История по (created_at, id). Со второй страницы Index Cond по
|
||||
(chat_id, created_at, id) начинает чтение сразу после cursor
|
||||
и останавливается после LIMIT строк.
|
||||
"""
|
||||
first_page_query = f"""
|
||||
SELECT
|
||||
message.id,
|
||||
message.chat_id,
|
||||
message.sender_id,
|
||||
message.text,
|
||||
message.created_at,
|
||||
{MESSAGE_ATTACHMENT_IDS}
|
||||
FROM messages message
|
||||
WHERE message.chat_id = $1
|
||||
ORDER BY message.created_at, message.id
|
||||
LIMIT $2;
|
||||
"""
|
||||
next_page_query = f"""
|
||||
SELECT
|
||||
message.id,
|
||||
message.chat_id,
|
||||
message.sender_id,
|
||||
message.text,
|
||||
message.created_at,
|
||||
{MESSAGE_ATTACHMENT_IDS}
|
||||
FROM messages message
|
||||
WHERE
|
||||
message.chat_id = $1
|
||||
AND (message.created_at, message.id) > ($2, $3)
|
||||
ORDER BY message.created_at, message.id
|
||||
LIMIT $4;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
if after is None:
|
||||
rows = await conn.fetch(first_page_query, chat_id, limit)
|
||||
else:
|
||||
rows = await conn.fetch(
|
||||
next_page_query, chat_id, after.created_at, after.id, limit
|
||||
)
|
||||
return [self._row_to_message(row) for row in rows]
|
||||
|
||||
@staticmethod
|
||||
def _row_to_message(
|
||||
row: asyncpg.Record, attachment_ids: list[UUID] | None = None
|
||||
) -> MessageSchema:
|
||||
"""attachment_ids — из запроса для только что вставленного сообщения"""
|
||||
return MessageSchema(
|
||||
id=row["id"],
|
||||
chat_id=row["chat_id"],
|
||||
sender_id=row["sender_id"],
|
||||
text=row["text"],
|
||||
created_at=row["created_at"],
|
||||
attachment_ids=(
|
||||
attachment_ids if attachment_ids is not None else row["attachment_ids"]
|
||||
),
|
||||
)
|
||||
@@ -0,0 +1,3 @@
|
||||
from .s3 import S3ObjectStorage, S3StoredObject
|
||||
|
||||
__all__ = ["S3ObjectStorage", "S3StoredObject"]
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user