ЛР 4 — БВТ2303 — Васюкова — на 4 #4
+22
-6
@@ -5,16 +5,32 @@ APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
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
|
||||
DATABASE_URL=postgresql://user:password@postgres:5432/high_load_messenger
|
||||
POSTGRES_USER=user
|
||||
POSTGRES_PASSWORD=password
|
||||
POSTGRES_DB=high_load_messenger
|
||||
# Redis. Пароль не задан: Redis доступен только внутри compose-сети (порт наружу не публикуется)
|
||||
REDIS_URL=redis://redis:6379/0
|
||||
SESSION_STORE=redis
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
S3_ENDPOINT=http://s3:9000
|
||||
|
||||
# --- MinIO / S3 (lab4) ---
|
||||
# Внутренний endpoint, доступен только из compose-сети.
|
||||
S3_ENDPOINT=http://minio:9000
|
||||
S3_REGION=us-east-1
|
||||
S3_BUCKET=messenger-attachments
|
||||
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
|
||||
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
|
||||
# Администратор MinIO (используется только minio и minio-init).
|
||||
MINIO_ROOT_USER=minioadmin
|
||||
MINIO_ROOT_PASSWORD=minioadmin-secret-change-me
|
||||
# Прикладные S3-credentials (ограниченные права). Используются API и cleanup.
|
||||
S3_APP_KEY_ID=messenger-app
|
||||
S3_APP_SECRET_KEY=messenger-app-secret-change-me
|
||||
# Лимиты (контракт + lab4)
|
||||
MAX_UPLOAD_BYTES=10485760
|
||||
MAX_IMAGE_PIXELS=40000000
|
||||
# Фоновая сверка S3↔БД (level 4)
|
||||
CLEANUP_INTERVAL_SECONDS=300
|
||||
# Grace period: объекты моложе N секунд не удаляются (защита in-flight uploads).
|
||||
ORPHAN_GRACE_SECONDS=3600
|
||||
|
||||
@@ -10,6 +10,7 @@ certs/private/
|
||||
*.jks
|
||||
*.pem
|
||||
*.tfstate*
|
||||
*.dump
|
||||
volumes/
|
||||
data/
|
||||
backups/
|
||||
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
# --- build stage ---
|
||||
FROM python:3.12-slim AS builder
|
||||
|
||||
WORKDIR /app
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt
|
||||
|
||||
# --- runtime stage ---
|
||||
FROM python:3.12-slim
|
||||
|
||||
# Непривилегированный пользователь
|
||||
RUN useradd --create-home --shell /bin/bash appuser
|
||||
|
||||
WORKDIR /app
|
||||
COPY --from=builder /install /usr/local
|
||||
COPY src/ ./src/
|
||||
COPY docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
|
||||
RUN chmod +x /usr/local/bin/docker-entrypoint.sh
|
||||
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONPATH=/app/src
|
||||
|
||||
USER appuser
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
|
||||
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live').read()"
|
||||
|
||||
ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
|
||||
CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--app-dir", "src"]
|
||||
@@ -4,10 +4,10 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence test-failover
|
||||
.PHONY: help check validate test test-student load test-persistence
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; test-student: own tests; load: synthetic writes"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -18,6 +18,9 @@ validate:
|
||||
test:
|
||||
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
test-student:
|
||||
$(PYTHON) student-tests/run_all.py --base-url "$(BASE_URL)"
|
||||
|
||||
load:
|
||||
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
|
||||
@@ -1,37 +1,263 @@
|
||||
# Отчёт — лабораторная 4
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Васюкова Наталья, БВТ2303
|
||||
- Целевая оценка: 4
|
||||
- Commit/PR: solution/BVT2303-Vasyukova
|
||||
- Использованные источники, библиотеки и помощь ИИ:
|
||||
- Контракт: contracts/openapi.json, contracts/README.md
|
||||
- Инструкции: README.md, COURSE.md, CONTRIBUTING.md
|
||||
- Библиотеки: fastapi==0.115.0, uvicorn[standard]==0.32.0, psycopg[binary]==3.2.3, psycopg_pool==3.2.3, redis==5.2.0, boto3==1.35.74, Pillow==11.0.0, pydantic (из fastapi)
|
||||
- ИИ: DeepSeek — помощь в структурировании кода и отчёта. Весь код проверен, отредактирован и запущен разработчиком.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Версии runtime/образов:
|
||||
- Python: 3.12 (образ `python:3.12-slim`)
|
||||
- FastAPI 0.115.0, uvicorn[standard] 0.32.0, psycopg[binary] 3.2.3, psycopg_pool 3.2.3, redis 5.2.0, boto3 1.35.74, Pillow 11.0.0
|
||||
- PostgreSQL 18.6-alpine, Redis 7.4.1-alpine, nginx 1.27.3-alpine
|
||||
- MinIO: `netvark/minio:20260213` (зеркало официального образа; оригинальные `minio/minio` удалены с Docker Hub). CLI `mc`: `netvark/mc:20260920`.
|
||||
- Docker Desktop (Windows)
|
||||
|
||||
### Запуск стека
|
||||
|
||||
1. Клонировать репозиторий и переключиться на ветку решения:
|
||||
```
|
||||
git clone https://gitflic.ru/project/vasyukova-nat/mtusi2026lab4.git
|
||||
git checkout solution/BVT2303-Vasyukova
|
||||
```
|
||||
2. Создать `.env` из шаблона:
|
||||
```
|
||||
copy .env.example .env
|
||||
```
|
||||
3. Собрать и поднять (LB + 2 реплики API + PostgreSQL + Redis + MinIO + minio-init + s3_cleanup):
|
||||
```
|
||||
docker compose --env-file .env up -d --build
|
||||
```
|
||||
4. Проверить готовность:
|
||||
```
|
||||
curl.exe -s http://localhost:8080/health/ready
|
||||
```
|
||||
Ожидается: `{"status":"ok"}`.
|
||||
|
||||
Все проверки ниже выполнялись с `PYTHONUTF8=1` (Windows по умолчанию использует cp1251 и падает на чтении UTF-8 JSON):
|
||||
```
|
||||
$env:PYTHONUTF8="1"
|
||||
```
|
||||
|
||||
### Проверки
|
||||
|
||||
`make` в среде автора недоступен (Windows без GNU Make), поэтому использованы эквивалентные прямые вызовы скриптов. Для Linux/CI рядом указаны команды `make`.
|
||||
|
||||
| Makefile-команда | Прямой вызов |
|
||||
| --- | --- |
|
||||
| `make check` | `python scripts/check_contract.py` |
|
||||
| `make validate` | `python scripts/validate_openapi.py` |
|
||||
| `make test` | `python tests/smoke.py --base-url http://localhost:8080` |
|
||||
| `make test-persistence` | `python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080` |
|
||||
| `make test-failover` | `python tests/resilience.py --mode failover --action-script scripts/stop-one.bat --base-url http://localhost:8080` |
|
||||
| `make test-student` | `python student-tests/lab4_test_level4.py --base-url http://localhost:8080` |
|
||||
|
||||
### Остановка и удаление учебных данных
|
||||
|
||||
```
|
||||
docker compose stop # данные PostgreSQL, Redis и MinIO сохраняются (volumes)
|
||||
docker compose down # volumes сохраняются
|
||||
docker compose down -v # ТОЛЬКО если осознанно стираем данные
|
||||
```
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Схема процессов и хранилищ:
|
||||
|
||||
```
|
||||
┌─ api-1 (uvicorn:8080, INSTANCE_ID=…)
|
||||
HTTP-клиент → lb:80 ──┤ ↘
|
||||
(nginx) └─ api-2 (uvicorn:8080, INSTANCE_ID=…) PostgreSQL 18.6 (метаданные)
|
||||
Redis 7.4.1 (сессии)
|
||||
MinIO (S3-байты, приватный bucket)
|
||||
s3_cleanup (сверка S3↔БД)
|
||||
```
|
||||
|
||||
Все сервисы — в одной compose-сети `mtuci2026lab4_default`. Публично опубликован только порт LB `127.0.0.1:8080:80`. Реплики `api` **не имеют `ports`** — трафик к ним идёт исключительно через LB. PostgreSQL, Redis и MinIO доступны только по внутренним именам (`postgres`, `redis`, `minio`). Административная консоль MinIO (`:9001`) и S3 API (`:9000`) **не публикуются** наружу.
|
||||
|
||||
Источники истины:
|
||||
- PostgreSQL — данные (пользователи, чаты, членство, сообщения) и ключи идемпотентности.
|
||||
- Redis — серверные сессии (общие для всех реплик).
|
||||
- MinIO (S3) — байты вложений (приватный bucket `messenger-attachments`).
|
||||
|
||||
Схема БД (подробнее — `src/app/storage/db.py`, константа `SCHEMA_SQL`):
|
||||
```
|
||||
users(id UUID PK, username TEXT UNIQUE, display_name TEXT, password_hash TEXT, created_at TIMESTAMPTZ)
|
||||
chats(id UUID PK, title TEXT, created_at TIMESTAMPTZ)
|
||||
chat_members(chat_id FK→chats, user_id FK→users, PK(chat_id,user_id))
|
||||
messages(id UUID PK, chat_id FK→chats, sender_id FK→users, text TEXT, created_at TIMESTAMPTZ)
|
||||
+ INDEX idx_messages_chat_created(chat_id, created_at, id)
|
||||
sessions(token TEXT PK, user_id FK→users, expires_at TIMESTAMPTZ) -- fallback SESSION_STORE=postgres
|
||||
idempotency_keys(user_id FK→users, method TEXT, path TEXT, key TEXT,
|
||||
body_hash TEXT, response_status INT, response_body JSONB, created_at TIMESTAMPTZ,
|
||||
PRIMARY KEY (user_id, method, path, key))
|
||||
+ INDEX idx_idempotency_created(created_at)
|
||||
attachments(id UUID PK, chat_id FK→chats, owner_id FK→users,
|
||||
filename TEXT, content_type TEXT, size_bytes BIGINT, sha256 TEXT,
|
||||
object_key TEXT UNIQUE, status TEXT, error_code TEXT,
|
||||
created_at TIMESTAMPTZ, updated_at TIMESTAMPTZ)
|
||||
+ INDEX idx_attachments_chat(chat_id)
|
||||
message_attachments(message_id FK→messages, attachment_id FK→attachments, position INT,
|
||||
PRIMARY KEY (message_id, attachment_id))
|
||||
+ INDEX idx_msg_att_message(message_id, position)
|
||||
```
|
||||
|
||||
Применяется идемпотентно через `init_schema()` в отдельном one-shot сервисе `migrate` (`python -m app.storage.db`). Все временные метки — `TIMESTAMPTZ`.
|
||||
|
||||
Транзакционные границы:
|
||||
- `create_user` — SELECT-проверка username и INSERT в одной транзакции; при гонке `UniqueViolation` → 409.
|
||||
- `create_chat` — INSERT `chats` + INSERT `chat_members` в одной транзакции, откат целиком.
|
||||
- `add_message_idempotent` — INSERT ключа идемпотентности, INSERT сообщения, INSERT связей с вложениями и UPDATE ответа ключа в **одной** транзакции.
|
||||
- Создание/отзыв сессии — одна операция.
|
||||
|
||||
### Дерево проекта (изменения относительно lab3 отмечены `*`)
|
||||
|
||||
```
|
||||
mtuci2026lab4/
|
||||
├── compose.yaml * # + minio, minio-init, s3_cleanup; lab4-network
|
||||
├── Dockerfile
|
||||
├── docker-entrypoint.sh # генерирует INSTANCE_ID, пишет /tmp/instance_id
|
||||
├── infra/nginx.conf
|
||||
├── Makefile
|
||||
├── requirements.txt * # + boto3, Pillow
|
||||
├── src/app/
|
||||
│ ├── main.py * # + attachments router, версия 1.4.0
|
||||
│ ├── api/
|
||||
│ │ ├── attachments.py * # новый: upload/get/download вложений
|
||||
│ │ ├── messages.py * # CreateMessage c attachment_ids, проверка принадлежности чату
|
||||
│ │ └── health.py * # + проверка S3
|
||||
│ ├── models/
|
||||
│ │ └── schemas.py * # + Attachment, Variant, Message.attachment_ids
|
||||
│ └── storage/
|
||||
│ ├── db.py * # + attachments, message_attachments
|
||||
│ ├── postgres.py * # + методы для вложений, идемпотентность с attachments
|
||||
│ └── s3.py * # новый: boto3-клиент, keyspace
|
||||
│ └── s3_cleanup.py * # новый: фоновая сверка S3↔БД
|
||||
├── scripts/
|
||||
│ ├── restart.sh / .bat * # + minio, s3_cleanup
|
||||
│ └── stop-one.sh / .bat # без изменений
|
||||
└── student-tests/
|
||||
└── lab4_test_level4.py * # новый: негативные тесты, компенсация, параллельные загрузки
|
||||
```
|
||||
|
||||
### Что нового в lab4 относительно lab3
|
||||
|
||||
1. **Разделение метаданных и байтов.** Метаданные вложений (`attachments`) живут в PostgreSQL; сами байты — в приватном S3-bucket в MinIO. Object key назначает сервер: `attachments/<chat_id>/<attachment_id>/original`, filename используется только для отображения (не как ключ).
|
||||
2. **Синхронный upload.** `POST /api/v1/chats/{chat_id}/attachments?filename=...` принимает сырые байты одного PNG/JPEG (не multipart, не base64). После PUT в S3 и INSERT в БД возвращает `201 Attachment` со `status=ready`. Порядок: сначала S3 PUT, потом INSERT. Если INSERT падает — объект удаляется из S3 (компенсация).
|
||||
3. **Авторизованный download.** `GET /api/v1/attachments/{id}` и `GET /api/v1/attachments/{id}/content` доступны только участникам чата. Байты отдаются через API без redirect. Приватный bucket сам по себе не заменяет ACL приложения.
|
||||
4. **Лимиты.** `MAX_UPLOAD_BYTES=10485760` (10 MiB) и `MAX_IMAGE_PIXELS=40000000` (40 млн пикселей). Лимит размера — до полного чтения (Content-Length + потоковое чтение с жёстким потолком); лимит пикселей — до полной распаковки (Pillow открывает заголовок и отдаёт `size` без `load()`). MIME определяется по байтам, не по заголовку.
|
||||
5. **Вложение в сообщении.** `POST /messages` принимает `attachment_ids` (0–10 уникальных UUID). Все ID должны принадлежать этому чату (иначе 404); failed прикреплять нельзя (в lab4 все ready). Можно отправить `text=""` с хотя бы одним вложением. Связь хранится в `message_attachments`, порядок сохраняется.
|
||||
6. **MinIO bootstrap.** `minio-init` создаёт bucket `messenger-attachments` (`mc mb --ignore-existing`), снимает анонимный доступ (`mc anonymous set none`), создаёт прикладного S3-пользователя `messenger-app` с ограниченной политикой (`s3:GetBucketLocation`, `s3:ListBucket`, `s3:GetObject`, `s3:PutObject`, `s3:DeleteObject`, `s3:AbortMultipartUpload`, `s3:ListMultipartUploadParts`). API использует эти ограниченные credentials; root (`MINIO_ROOT_USER`) остаётся только у `minio`/`minio-init`.
|
||||
7. **Компенсация orphan.** При сбое между S3 PUT и INSERT API удаляет S3-объект и отдаёт 503. Дополнительно `s3_cleanup` раз в `CLEANUP_INTERVAL_SECONDS` (по умолчанию 300 с) сверяет S3↔БД: объекты в S3 без метаданных старше `ORPHAN_GRACE_SECONDS` (по умолчанию 3600 с) удаляются; метаданные без объекта логируются как `missing_object`. Grace period защищает от удаления in-flight uploads.
|
||||
8. **Readiness.** `/health/ready` теперь проверяет PostgreSQL, Redis (в режиме redis) и S3. S3 — критичная зависимость для обязательного синхронного пути загрузки.
|
||||
|
||||
Соответствие `.env.example` реальной конфигурации:
|
||||
- `APP_HOST`, `APP_PORT` — используются uvicorn/CMD в Dockerfile.
|
||||
- `APP_ENV` — пишется в стартовый лог, на логику не влияет.
|
||||
- `SESSION_TTL_SECONDS` — TTL серверных сессий в Redis (или в таблице `sessions` при `SESSION_STORE=postgres`), по умолчанию 3600.
|
||||
- `DATABASE_URL` — строка подключения к PostgreSQL.
|
||||
- `REDIS_URL` — адрес Redis в compose-сети.
|
||||
- `SESSION_STORE` — `redis` (уровень 4) или `postgres` (fallback).
|
||||
- `S3_ENDPOINT` — внутренний адрес MinIO (`http://minio:9000`).
|
||||
- `S3_REGION` — регион (для MinIO фиктивный `us-east-1`).
|
||||
- `S3_BUCKET` — имя приватного bucket.
|
||||
- `MINIO_ROOT_USER` / `MINIO_ROOT_PASSWORD` — root-credentials MinIO, используются только сервисами `minio` и `minio-init`.
|
||||
- `S3_APP_KEY_ID` / `S3_APP_SECRET_KEY` — прикладные S3-credentials, используются API и `s3_cleanup`.
|
||||
- `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS` — лимиты вложений.
|
||||
- `CLEANUP_INTERVAL_SECONDS` — период сверки S3↔БД.
|
||||
- `ORPHAN_GRACE_SECONDS` — grace period для удаления orphan-объектов.
|
||||
- `CACHE_URL_FILE` — резервная переменная из скелета, не используется.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| Критерий | Команда | Наблюдаемый результат | Уровень |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Публичный smoke | `python tests/smoke.py` | PASS: lab4 public API scenario | 3 |
|
||||
| S3-сервер в общем стенде, приватный bucket | `docker compose ps`; `minio-init` | minio/minio-init/s3_cleanup Up; bucket `messenger-attachments` создан | 3 |
|
||||
| Метаданные в PostgreSQL, байты в S3 | smoke: `POST /attachments`, `GET /content` | 201 ready, SHA-256 оригинала совпадает с `sha256` в ответе, байты скачаны побайтно | 3 |
|
||||
| Вложение читается участниками чата; посторонний → 404 | smoke, `lab4_test_level4.py::test_foreign_attachment_and_cross_chat` | PASS: foreign → 404, cross-chat → 404 | 3 |
|
||||
| PNG/JPEG ≤10 MiB, ≤40M пикселей, MIME по содержимому | `lab4_test_level4.py::test_oversize`, `test_corrupted_image`, `test_mime_spoof` | 413, 415, 415 | 3 |
|
||||
| Опасный filename отклоняется | `lab4_test_level4.py::test_bad_filename` | 400 для `../`, `/`, `\`, `\x00`, `\n` | 3 |
|
||||
| Upload → stop replica → download через другую | `resilience.py --mode failover` | observed_instances_before=2, successful_writes=8, first_recovery=4.146 s, PASS | 3 |
|
||||
| Restart сохраняет метаданные и оригинал | `resilience.py --mode persistence` | PASS (исходный файл сверен по SHA-256) | 3 |
|
||||
| Пользовательская ошибка не превращается в 500 | `lab4_test_level4.py` (все негативные кейсы) | 4xx, не 5xx | 4 |
|
||||
| Отказ между S3 PUT и INSERT не оставляет orphan | `lab4_test_level4.py::test_compensation_on_db_failure` | 503, bucket не вырос (before=10, after=10) | 4 |
|
||||
| ≥10 параллельных загрузок, пик RSS | `lab4_test_level4.py::test_parallel_uploads_memory` | 10 загрузок, пик RSS=88.94 MiB (<400 MiB) | 4 |
|
||||
| Прикладные S3-credentials с ограниченной политикой | `minio-init` (mc admin policy) | API использует `S3_APP_KEY_ID`; root только у minio/minio-init | 4 |
|
||||
| Приватный bucket вне API | `docker run ... mc anonymous get` | `none`; `curl` без credentials → 403 | 4 |
|
||||
| Bucket bootstrap идемпотентен | повторный `docker compose up -d minio-init` | не падает; bucket/user/policy не пересоздаются | 4 |
|
||||
| Административная консоль не открыта наружу | `compose.yaml` | у `minio` нет `ports:`; `localhost:9001` недоступен | 4 |
|
||||
| Компенсация/сверка документирована | `src/app/storage/s3_cleanup.py` + `ORPHAN_GRACE_SECONDS` | лог `event=orphan_deleted` (см. Эксперименты) | 4 |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
### Выводы тестов
|
||||
|
||||
```
|
||||
(venv) PS ...> python scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
|
||||
(venv) PS ...> python scripts/validate_openapi.py
|
||||
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
|
||||
|
||||
(venv) PS ...> python tests/smoke.py --base-url http://localhost:8080
|
||||
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
|
||||
|
||||
(venv) PS ...> python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080
|
||||
PASS: persistence preserved confirmed data and existing session.
|
||||
|
||||
(venv) PS ...> python tests/resilience.py --mode failover --action-script scripts/stop-one.bat --base-url http://localhost:8080
|
||||
{"observed_instances_before": 2, "successful_writes": 8, "failed_attempts": 0, "first_recovery_seconds": 4.146}
|
||||
PASS: failover preserved confirmed data and existing session.
|
||||
|
||||
(venv) PS ...> python student-tests/lab4_test_level4.py --base-url http://localhost:8080
|
||||
=== oversize ===
|
||||
PASS: oversize -> 413
|
||||
=== corrupted image ===
|
||||
PASS: corrupted -> 415
|
||||
=== spoofed MIME ===
|
||||
PASS: spoofed MIME -> 415
|
||||
=== bad filename ===
|
||||
PASS: bad filename -> 400
|
||||
=== foreign attachment / cross-chat ===
|
||||
PASS: foreign -> 404, cross-chat -> 404
|
||||
=== attachment belongs to chat ===
|
||||
PASS: attachment from another chat -> 404
|
||||
=== compensation on DB failure ===
|
||||
upload при мёртвой БД вернул 503
|
||||
компенсация: bucket не вырос (before=10 after=10)
|
||||
PASS: компенсация orphan-объектов при отказе БД
|
||||
=== parallel uploads memory ===
|
||||
10 параллельных загрузок, пик RSS=88.94 MiB
|
||||
PASS: 10 параллельных загрузок в пределах лимита памяти
|
||||
PASS: all lab4 level-4 checks passed
|
||||
```
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Hardware: Windows 11, Docker Desktop (WSL2). Лимиты контейнеров заданы в `compose.yaml` (`api`: 1 CPU / 512M; `minio`: 1 CPU / 512M; `s3_cleanup`: 0.3 CPU / 256M). Синтетические данные (см. `tests/smoke.py`, `student-tests/lab4_test_level4.py`).
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| `docker compose stop postgres` во время upload | S3 PUT прошёл, INSERT падает, компенсация удаляет объект, ответ 503 | 503, bucket не вырос (`before=10`, `after=10`) | 0; после `start postgres` — ready за ≤90 с, по факту ~10 с |
|
||||
| `docker stop` одной API-реплики (failover) | Вторая реплика продолжает обслуживать; подтверждённое не теряется; идемпотентность без дублей | 2 реплики до, 8 успешных записей, 0 ошибок, recovery=4.146 s | ≤10 с; потери нет |
|
||||
| `scripts/restart.bat` (LB, обе реплики, Postgres, Redis, MinIO, s3_cleanup) | Данные PostgreSQL/Redis и оригинал в S3 сохраняются, сессия продолжает работать | PASS: тот же токен и тот же SHA-256 файла после перезапуска | Готовность ≤90 с; потери нет |
|
||||
| 10 одновременных загрузок `sample.png` | Все 201; пик RSS API ограничен | 10×201, пик RSS=88.94 MiB | — |
|
||||
| Ручное удаление строки `attachments` (orphan) + ожидание grace | `s3_cleanup` удаляет объект, в логе `event=orphan_deleted` | `docker compose logs s3_cleanup`: `event=orphan_deleted key=attachments/.../original` | ≤`CLEANUP_INTERVAL_SECONDS + ORPHAN_GRACE_SECONDS` |
|
||||
| Upload с `MAX_UPLOAD_BYTES=10485761` | 413 до сохранения в S3 | 413, объект не появился в bucket | 0 |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- **Один Docker-host.** Отказ узла не проверялся; LB, PostgreSQL, Redis, MinIO — единичные экземпляры (SPOF). HA БД/LB/S3 не заявляется.
|
||||
- **MinIO без репликации.** Один bucket, один сервер. Отказ диска MinIO = потеря оригиналов, если не настроить репликацию/бэкап. Для уровня 4 это не требуется.
|
||||
- **Обнаружение отказа API — реактивное.** LB узнаёт о мёртвой реплике по первой ошибке (`proxy_next_upstream`), поэтому возможна короткая задержка ~4–5 с до исключения из ротации. Это укладывается в ≤10 с по методичке.
|
||||
- **Компенсация «S3 → БД».** Основной путь — удалить S3-объект при ошибке INSERT. Обратный случай (метаданные есть, S3-объект потерян) ловится `s3_cleanup` как `missing_object`, но не «самолечится» (файл восстановить неоткуда). Для учебного стенда этого достаточно.
|
||||
- **`s3_cleanup` — best-effort.** Если процесс упал во время цикла, при следующем запуске сверка продолжается. БД и S3 читаются без блокировок, гонки с in-flight upload защищены `ORPHAN_GRACE_SECONDS`.
|
||||
- **Память загрузки.** Тело загрузки читается в память (`chunks: list[bytes]`). При `MAX_UPLOAD_BYTES=10 MiB` и `api` limit 512M пик RSS 88.94 MiB при 10 параллельных загрузках — приемлемо. Для больших лимитов потребуется потоковая отправка в S3 (`upload_fileobj`) вместо буфера; для уровня 4 не требуется.
|
||||
- **Pillow в threadpool.** Валидация изображения выполняется в `run_in_threadpool`, чтобы не блокировать event loop. Порог пикселей берётся из заголовка до полной распаковки; «бомба» с маленьким заголовком и большим `load()` не пройдёт лимит по пикселям, а реальное декодирование отложено до клиента (побайтовая сверка sha256 всё равно сходится при скачивании).
|
||||
- **Идемпотентность только на POST сообщения.** `POST /users`, `POST /chats`, `POST /attachments` без `Idempotency-Key` — повтор создаёт новый объект, что соответствует контракту.
|
||||
- **Часы.** Порядок `(created_at, id)` требует монотонности `created_at` в пределах сервера; для учебного стенда с одной БД это выполняется.
|
||||
- **Нагрузка.** Полноценных замеров RPS/p50/p95/p99 при фиксированных ресурсах не проводилось — для целевой оценки 4 это не требуется. Трек 5 (presigned-upload или reconciler) не заявлен.
|
||||
+280
@@ -0,0 +1,280 @@
|
||||
x-lab-number: 4
|
||||
x-required-roles:
|
||||
- api
|
||||
- postgres
|
||||
- load_balancer
|
||||
- s3
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:18.6-alpine
|
||||
container_name: mtuci-postgres
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER:-messenger}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-messenger}
|
||||
POSTGRES_DB: ${POSTGRES_DB:-high_load_messenger}
|
||||
volumes:
|
||||
- postgres-data:/var/lib/postgresql
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-high_load_messenger}"]
|
||||
interval: 5s
|
||||
timeout: 5s
|
||||
retries: 20
|
||||
start_period: 30s
|
||||
restart: unless-stopped
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 1G
|
||||
reservations:
|
||||
cpus: "0.25"
|
||||
memory: 256M
|
||||
|
||||
redis:
|
||||
image: redis:7.4.1-alpine
|
||||
container_name: mtuci-redis
|
||||
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec", "--save", "60", "1"]
|
||||
volumes:
|
||||
- redis-data:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
start_period: 3s
|
||||
restart: unless-stopped
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 256M
|
||||
reservations:
|
||||
cpus: "0.1"
|
||||
memory: 64M
|
||||
|
||||
minio:
|
||||
image: netvark/minio:20260213
|
||||
container_name: mtuci-minio
|
||||
command: ["server", "/data", "--console-address", ":9001"]
|
||||
environment:
|
||||
MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin}
|
||||
MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minioadmin}
|
||||
MINIO_BROWSER_REDIRECT_URL: http://localhost:9001
|
||||
volumes:
|
||||
- minio-data:/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "curl -f http://localhost:9000/minio/health/live || exit 1"]
|
||||
interval: 5s
|
||||
timeout: 5s
|
||||
retries: 20
|
||||
start_period: 5s
|
||||
restart: unless-stopped
|
||||
# Консоль администратора НЕ публикуется наружу; доступ только из сети compose.
|
||||
# Порт 9000 (S3 API) тоже внутренний — публичного доступа нет.
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 512M
|
||||
reservations:
|
||||
cpus: "0.1"
|
||||
memory: 128M
|
||||
|
||||
minio-init:
|
||||
image: netvark/mc:20260920
|
||||
container_name: mtuci-minio-init
|
||||
depends_on:
|
||||
minio:
|
||||
condition: service_healthy
|
||||
entrypoint: ["/bin/sh", "-c"]
|
||||
command:
|
||||
- |
|
||||
set -eu
|
||||
mc alias set local http://minio:9000 "$${MINIO_ROOT_USER}" "$${MINIO_ROOT_PASSWORD}"
|
||||
# Приватный bucket; idempotent.
|
||||
mc mb --ignore-existing local/"$${S3_BUCKET}"
|
||||
# Политика: bucket не публичный. Явно none.
|
||||
mc anonymous set none local/"$${S3_BUCKET}" || true
|
||||
# Прикладные S3-credentials с ограниченными правами на префикс приложения.
|
||||
# Политика выдаётся через `mc admin policy`; создаём отдельного пользователя.
|
||||
if ! mc admin user info local "$${S3_APP_KEY_ID}" >/dev/null 2>&1; then
|
||||
mc admin user add local "$${S3_APP_KEY_ID}" "$${S3_APP_SECRET_KEY}"
|
||||
fi
|
||||
cat > /tmp/app-policy.json <<'POLICY'
|
||||
{
|
||||
"Version": "2012-10-17",
|
||||
"Statement": [
|
||||
{
|
||||
"Effect": "Allow",
|
||||
"Action": ["s3:GetBucketLocation", "s3:ListBucket"],
|
||||
"Resource": ["arn:aws:s3:::${S3_BUCKET}"]
|
||||
},
|
||||
{
|
||||
"Effect": "Allow",
|
||||
"Action": [
|
||||
"s3:GetObject", "s3:PutObject", "s3:DeleteObject",
|
||||
"s3:AbortMultipartUpload", "s3:ListMultipartUploadParts"
|
||||
],
|
||||
"Resource": ["arn:aws:s3:::${S3_BUCKET}/*"]
|
||||
}
|
||||
]
|
||||
}
|
||||
POLICY
|
||||
# Подставляем имя bucket в политику
|
||||
sed -i "s/\$${S3_BUCKET}/$${S3_BUCKET}/g" /tmp/app-policy.json || true
|
||||
mc admin policy create local messenger-app /tmp/app-policy.json 2>/dev/null || true
|
||||
mc admin policy attach local messenger-app --user "$${S3_APP_KEY_ID}" || true
|
||||
echo "minio-init done"
|
||||
# Административные credentials нужны только здесь и в minio.
|
||||
environment:
|
||||
MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin}
|
||||
MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minioadmin}
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_APP_KEY_ID: ${S3_APP_KEY_ID:-messenger-app}
|
||||
S3_APP_SECRET_KEY: ${S3_APP_SECRET_KEY:-messenger-app-secret-change-me}
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.2"
|
||||
memory: 64M
|
||||
|
||||
migrate:
|
||||
build: .
|
||||
image: mtuci-messenger:lab4
|
||||
command: ["python", "-m", "app.storage.db"]
|
||||
# Явный whitelist переменных: без MINIO_ROOT_USER/PASSWORD.
|
||||
environment:
|
||||
APP_ENV: ${APP_ENV:-lab}
|
||||
DATABASE_URL: ${DATABASE_URL}
|
||||
SESSION_STORE: ${SESSION_STORE:-redis}
|
||||
REDIS_URL: ${REDIS_URL:-redis://redis:6379/0}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 256M
|
||||
reservations:
|
||||
cpus: "0.1"
|
||||
memory: 64M
|
||||
|
||||
api:
|
||||
build: .
|
||||
image: mtuci-messenger:lab4
|
||||
# Явный whitelist переменных: приложение не получает административные
|
||||
# credentials MinIO (MINIO_ROOT_USER/PASSWORD). Для S3 — только
|
||||
# прикладные S3_APP_KEY_ID/S3_APP_SECRET_KEY с ограниченной политикой.
|
||||
environment:
|
||||
APP_HOST: ${APP_HOST:-0.0.0.0}
|
||||
APP_PORT: ${APP_PORT:-8080}
|
||||
APP_ENV: ${APP_ENV:-lab}
|
||||
DATABASE_URL: ${DATABASE_URL}
|
||||
SESSION_STORE: ${SESSION_STORE:-redis}
|
||||
REDIS_URL: ${REDIS_URL:-redis://redis:6379/0}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
|
||||
S3_ENDPOINT: ${S3_ENDPOINT:-http://minio:9000}
|
||||
S3_REGION: ${S3_REGION:-us-east-1}
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_APP_KEY_ID: ${S3_APP_KEY_ID}
|
||||
S3_APP_SECRET_KEY: ${S3_APP_SECRET_KEY}
|
||||
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
|
||||
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
|
||||
CLEANUP_INTERVAL_SECONDS: ${CLEANUP_INTERVAL_SECONDS:-300}
|
||||
ORPHAN_GRACE_SECONDS: ${ORPHAN_GRACE_SECONDS:-3600}
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
minio-init:
|
||||
condition: service_completed_successfully
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready').read()"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
start_period: 10s
|
||||
restart: unless-stopped
|
||||
deploy:
|
||||
replicas: 2
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 512M
|
||||
reservations:
|
||||
cpus: "0.25"
|
||||
memory: 128M
|
||||
|
||||
# Уровень 4: фоновая сверка S3↔БД (orphan-объекты и missing).
|
||||
# Запускается как долгоживущий сервис, спит CLEANUP_INTERVAL_SECONDS.
|
||||
s3_cleanup:
|
||||
build: .
|
||||
image: mtuci-messenger:lab4
|
||||
command: ["python", "-m", "app.storage.s3_cleanup"]
|
||||
# Явный whitelist переменных: без административных кредов MinIO.
|
||||
environment:
|
||||
APP_ENV: ${APP_ENV:-lab}
|
||||
DATABASE_URL: ${DATABASE_URL}
|
||||
S3_ENDPOINT: ${S3_ENDPOINT:-http://minio:9000}
|
||||
S3_REGION: ${S3_REGION:-us-east-1}
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_APP_KEY_ID: ${S3_APP_KEY_ID}
|
||||
S3_APP_SECRET_KEY: ${S3_APP_SECRET_KEY}
|
||||
CLEANUP_INTERVAL_SECONDS: ${CLEANUP_INTERVAL_SECONDS:-300}
|
||||
ORPHAN_GRACE_SECONDS: ${ORPHAN_GRACE_SECONDS:-3600}
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
minio-init:
|
||||
condition: service_completed_successfully
|
||||
restart: unless-stopped
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.3"
|
||||
memory: 256M
|
||||
reservations:
|
||||
cpus: "0.05"
|
||||
memory: 64M
|
||||
|
||||
lb:
|
||||
image: nginx:1.27.3-alpine
|
||||
container_name: mtuci-lb
|
||||
ports:
|
||||
- "127.0.0.1:8080:80"
|
||||
volumes:
|
||||
- ./infra/nginx.conf:/etc/nginx/conf.d/default.conf:ro
|
||||
depends_on:
|
||||
api:
|
||||
condition: service_healthy
|
||||
restart: unless-stopped
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 128M
|
||||
reservations:
|
||||
cpus: "0.1"
|
||||
memory: 32M
|
||||
|
||||
volumes:
|
||||
postgres-data:
|
||||
name: mtuci2026lab4_postgres-data
|
||||
redis-data:
|
||||
name: mtuci2026lab4_redis-data
|
||||
minio-data:
|
||||
name: mtuci2026lab4_minio-data
|
||||
|
||||
networks:
|
||||
default:
|
||||
name: mtuci2026lab4_default
|
||||
@@ -0,0 +1,13 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# X-Instance-Id: если INSTANCE_ID не задан снаружи, генерируем уникальный
|
||||
# для этого контейнера при старте. Кладём его в файл /tmp/instance_id,
|
||||
# чтобы stop-one.bat/.sh могли сопоставить alias и контейнер.
|
||||
if [ -z "${INSTANCE_ID:-}" ]; then
|
||||
INSTANCE_ID=$(python -c "import uuid; print(uuid.uuid4().hex[:12])")
|
||||
export INSTANCE_ID
|
||||
fi
|
||||
echo "event=instance_id instance_id=${INSTANCE_ID}"
|
||||
echo -n "${INSTANCE_ID}" > /tmp/instance_id
|
||||
|
||||
exec "$@"
|
||||
@@ -0,0 +1,58 @@
|
||||
|
||||
=== Лабораторная 1. Результаты проверки контракта и публичного smoke ===
|
||||
Автор: Васюкова Наталья, группа БВТ2303
|
||||
Дата: 2026-09-25
|
||||
Стенд: Windows 11, PowerShell, Python 3.14.5 (venv), Docker Desktop
|
||||
Образ: mtusi-messenger:lab1 (python:3.12-slim, multi-stage)
|
||||
|
||||
Примечание: команды make недоступны в PowerShell, поэтому
|
||||
использованы эквивалентные прямые вызовы скриптов из Makefile через Python
|
||||
(эквивалентные команды указаны рядом).
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
1. make check -> python scripts/check_contract.py
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
|
||||
Наблюдение: структура репозитория целостна (скелет не изменён): lab.json и версия в openapi.json
|
||||
согласованы, все $ref локальные, у всех ответов есть X-Request-Id,
|
||||
path-параметры совпадают с шаблоном пути, скрипты tests/ и scripts/
|
||||
синтаксически корректны, обязательные файлы на месте.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
2. make validate -> python scripts/validate_openapi.py
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python scripts/validate_openapi.py
|
||||
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
|
||||
|
||||
Наблюдение: контракт contracts/openapi.json прошёл полную валидацию по OpenAPI 3.1,
|
||||
примеры из contracts/examples.json соответствуют схемам компонентов.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
3. make test -> python tests/smoke.py --base-url http://localhost:8080
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python tests/smoke.py --base-url http://localhost:8080
|
||||
PASS: lab1 public API scenario; infrastructure and grading evidence remain separate.
|
||||
|
||||
Наблюдение: сквозной публичный сценарий ЛР1 пройден. Тест проверяет API-поведение:
|
||||
- GET /health/live и /health/ready возвращают 200;
|
||||
- POST /api/v1/users создаёт пользователей, повтор username -> 409;
|
||||
- GET /api/v1/users/me: без X-User-Id -> 401, с валидным -> 200;
|
||||
- POST /api/v1/chats: членство, изоляция от постороннего (404);
|
||||
- GET /api/v1/chats и /messages с limit/cursor: без потерь и повторов;
|
||||
- Unicode-текст сообщений, sender_id выводится из актора;
|
||||
- негативные сценарии: пустой текст -> 400, чужой чат -> 404, limit=0 -> 400;
|
||||
- ответы валидируются по JSON-схемам из contracts/openapi.json.
|
||||
Примечание: smoke не доказывает persistence, HA и не выставляет оценку —
|
||||
это подтверждено отдельно в lab1_lifecycle.txt.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
ИТОГ
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Все три проверки пройдены.
|
||||
@@ -0,0 +1,155 @@
|
||||
=== Лабораторная 1. Доказательства уровня 4 ===
|
||||
Автор: Васюкова Наталья, группа БВТ2303
|
||||
Дата: 2026-09-25
|
||||
Стенд: Windows 11, PowerShell, Python 3.12 (venv), Docker Desktop
|
||||
Образ: mtusi-messenger:lab1 (python:3.12-slim, multi-stage)
|
||||
Commit: solution/BVT2303-Vasyukova
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
1. Собственные негативные тесты
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python student-tests/test_negative.py --base-url http://localhost:8080
|
||||
PASS: lab1 negative scenarios (dup, malformed JSON, extra fields, wrong type,
|
||||
empty text, foreign chat, pagination, bad limit, unknown user)
|
||||
|
||||
Наблюдение: проверены сценарии — повтор username -> 409; malformed JSON -> 400;
|
||||
лишние поля -> 400; неверный тип поля -> 400; пустое/пробельное сообщение -> 400;
|
||||
доступ к чужому чату (GET чата, GET сообщений, POST сообщения) -> 404;
|
||||
обход нескольких страниц cursor-пагинации без потерь, дублей и изменения порядка;
|
||||
limit=0 и limit=101 -> 400; неизвестный UUID в X-User-Id -> 401.
|
||||
Все ответы об ошибках соответствуют формату contracts/openapi.json
|
||||
(code/message/request_id), request_id совпадает с заголовком X-Request-Id.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
2. Конкурентный тест: 100 сообщений от 10 клиентов
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python student-tests/test_concurrency.py --base-url http://localhost:8080
|
||||
PASS: lab1 concurrency: 100 messages from 10 clients, 100 unique stored and readable
|
||||
|
||||
Наблюдение: 10 параллельных клиентов, синхронизированных барьером, одновременно
|
||||
отправили по 10 POST /api/v1/chats/{chat_id}/messages. Получено ровно 100
|
||||
уникальных message id; при полном чтении истории через пагинацию
|
||||
(limit=100) получено ровно те же 100 уникальных записей, без потерь и дублей.
|
||||
Это подтверждает атомарность операций MemoryStorage под threading.RLock.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
3. Единая команда запуска собственных тестов
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python student-tests/run_all.py --base-url http://localhost:8080
|
||||
=== test_negative.py ===
|
||||
PASS: lab1 negative scenarios (dup, malformed JSON, extra fields, wrong type, empty text, foreign chat, pagination, bad limit, unknown user)
|
||||
=== test_concurrency.py ===
|
||||
PASS: lab1 concurrency: 100 messages from 10 clients, 100 unique stored and readable
|
||||
PASS: all student tests (level 4) passed
|
||||
|
||||
(Эквивалент через Makefile: make test-student BASE_URL=http://localhost:8080)
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
4. Обработка SIGTERM
|
||||
--------------------------------------------------------------------
|
||||
|
||||
В терминале 1:
|
||||
$ docker run --rm --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
|
||||
В терминале 2:
|
||||
Цикл опроса TCP-порта 8080 (TcpClient, жёсткий таймаут 500 мс):
|
||||
```
|
||||
while ($true) {
|
||||
$t = Get-Date -Format "HH:mm:ss.fff"
|
||||
$client = New-Object System.Net.Sockets.TcpClient
|
||||
try {
|
||||
$iar = $client.BeginConnect("127.0.0.1", 8080, $null, $null)
|
||||
$ok = $iar.AsyncWaitHandle.WaitOne(500)
|
||||
if ($ok -and $client.Connected) {
|
||||
Write-Host "$t OPEN"
|
||||
} else {
|
||||
Write-Host "$t CLOSED"
|
||||
}
|
||||
} catch {
|
||||
Write-Host "$t CLOSED"
|
||||
} finally {
|
||||
$client.Close()
|
||||
}
|
||||
Start-Sleep -Milliseconds 200
|
||||
}
|
||||
```
|
||||
В терминале 3:
|
||||
$ docker stop -t 10 mtusi-messenger-lab1
|
||||
Замер времени завершения:
|
||||
$ $t = Measure-Command { docker stop -t 10 mtusi-messenger-lab1 }
|
||||
$ "Stop took: $($t.TotalSeconds) s"
|
||||
Stop took: 0.7416883 s
|
||||
|
||||
Фрагмент вывода терминала 2:
|
||||
02:06:06.269 OPEN
|
||||
02:06:06.497 CLOSED
|
||||
|
||||
Фрагмент лога контейнера:
|
||||
INFO: Shutting down
|
||||
INFO: Waiting for application shutdown.
|
||||
2026-09-25 23:06:05,866 INFO app event=shutdown_complete
|
||||
INFO: Application shutdown complete.
|
||||
INFO: Finished server process [1]
|
||||
|
||||
Наблюдение: контейнер завершился за ~0.74 с (существенно быстрее grace-period 10 с).
|
||||
Порт закрылся (первый CLOSED) через ~0.2 с после сигнала, не дожидаясь grace-period;
|
||||
`event=shutdown_complete` и `Finished server process [1]` идут сразу после.
|
||||
Строка `event=sigterm_received` в логе не появляется: сигнал перехватывает
|
||||
встроенный механизм uvicorn (обработчик SIGTERM) раньше нашего хендлера _handle_sigterm.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
5. Логи без содержимого сообщений
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Пример строк лога контейнера (meta-only):
|
||||
|
||||
2026-09-25 ... INFO app event=http method=POST path=/api/v1/chats status=201 duration_ms=3.12 request_id=...
|
||||
2026-09-25 ... INFO app event=http method=POST path=/api/v1/chats/<uuid>/messages status=201 duration_ms=2.01 request_id=...
|
||||
2026-09-25 ... INFO app event=startup app_env=lab
|
||||
2026-09-25 ... INFO app event=shutdown_complete
|
||||
|
||||
Наблюдение: лог содержит метод, путь (без query), статус, длительность и
|
||||
X-Request-Id. Текст сообщений, значения X-User-Id, пароли и токены в лог
|
||||
не попадают. Ошибки 500 логируются только типом исключения и request_id,
|
||||
без stack trace в ответе и без внутренних деталей.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
6. Конфигурация контейнера (уровень 4)
|
||||
--------------------------------------------------------------------
|
||||
|
||||
- Dockerfile: базовый образ python:3.12-slim (multi-stage), зависимости
|
||||
закреплены (fastapi==0.115.0, uvicorn[standard]==0.32.0).
|
||||
- Процесс работает от непривилегированного пользователя appuser
|
||||
(RUN useradd --create-home ... ; USER appuser).
|
||||
- HEALTHCHECK обращается к /health/live (interval=10s, timeout=3s,
|
||||
start-period=5s, retries=3).
|
||||
- .dockerignore исключает .env, secrets, certs, volumes, backups,
|
||||
*.key/*.pem/*.p12/*.pfx/*.jks, .venv, __pycache__, node_modules,
|
||||
evidence, .DS_Store. В образ не копируются локальные секреты.
|
||||
|
||||
Проверка:
|
||||
$ docker inspect --format "{{.Config.User}}" mtusi-messenger-lab1
|
||||
appuser
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
ИТОГ
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Результаты:
|
||||
- собственные негативные тесты — PASS;
|
||||
- конкурентный тест 100/10 — PASS, 100 уникальных сообщений;
|
||||
- единая команда запуска test-student — PASS;
|
||||
- SIGTERM: контейнер останавливается за ~0.74 с, порт закрывается через
|
||||
~0.2 с после сигнала (не дожидаясь grace-period 10 с);
|
||||
- непривилегированный пользователь appuser, закреплённые версии,
|
||||
.dockerignore;
|
||||
- healthcheck настроен; логи структурированные, без содержимого сообщений.
|
||||
@@ -0,0 +1,58 @@
|
||||
=== Лабораторная 1. Демонстрация жизненного цикла in-memory состояния ===
|
||||
Автор: Васюкова Наталья, группа БВТ2303
|
||||
Дата: 2026-09-25
|
||||
Цель: показать, что состояние хранится только в памяти процесса и исчезает
|
||||
после перезапуска контейнера.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
1. До перезапуска: пользователь существует
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Пользователь создан через Swagger. Получен его id.
|
||||
|
||||
Проверка:
|
||||
$ curl.exe -s http://localhost:8080/api/v1/users/me -H "X-User-Id: aca0efda-7a1b-44c0-a8ba-c4f1e636a8de"
|
||||
{"id":"aca0efda-7a1b-44c0-a8ba-c4f1e636a8de","username":"vasyukova","display_name":"Vasyukova","created_at":"2026-09-25T12:09:23.431720Z"}
|
||||
|
||||
HTTP-статус: 200 OK
|
||||
Наблюдение: пользователь с заданным UUID найден, поля ответа соответствуют схеме User из contracts/openapi.json.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
2. Остановка контейнера
|
||||
--------------------------------------------------------------------
|
||||
|
||||
В терминале с запущенным контейнером:
|
||||
Ctrl+C.
|
||||
Проверка:
|
||||
$ docker ps
|
||||
В списке запущенных контейнеров отсутствует mtusi-messenger-lab1. Контейнер остановлен (использован флаг --rm, контейнер удалён автоматически).
|
||||
|
||||
--------------------------------------------------------------------
|
||||
3. Повторный запуск контейнера
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ docker run --rm --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
|
||||
Uvicorn запущен на http://0.0.0.0:8080, контейнер готов принимать запросы.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
4. После перезапуска: пользователь отсутствует
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Повторная проверка:
|
||||
$ curl.exe -s -i http://localhost:8080/api/v1/users/me -H "X-User-Id: aca0efda-7a1b-44c0-a8ba-c4f1e636a8de"
|
||||
|
||||
HTTP/1.1 401 Unauthorized
|
||||
{"error":{"code":"unauthorized","message":"unauthorized","request_id":"99343c4086e249afacc585fa9399ef3b"}}
|
||||
|
||||
HTTP-статус: 401 Unauthorized
|
||||
Наблюдение: тот же X-User-Id больше не существует в хранилище.
|
||||
Формат ошибки соответствует контракту (code/message/request_id), request_id непустой.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
ВЫВОД
|
||||
--------------------------------------------------------------------
|
||||
|
||||
После перезапуска пользователь исчез. Это подтверждает, что состояние ЛР1 хранится только в оперативной памяти
|
||||
процесса Uvicorn. Volumes, БД, файлы состояния не используются. Поведение
|
||||
соответствует требованию лабораторной: данные намеренно исчезают после перезапуска процесса.
|
||||
@@ -0,0 +1,24 @@
|
||||
{
|
||||
"lab": 1,
|
||||
"track": 1,
|
||||
"variant": "after",
|
||||
"profile": {
|
||||
"history_sizes": [100, 1000, 5000],
|
||||
"concurrency_levels": [1, 4, 16],
|
||||
"duration_seconds": 10,
|
||||
"note": "closed-loop; клиент ограничивает throughput; RSS — docker stats; sort on read REMOVED"
|
||||
},
|
||||
"points": [
|
||||
{"history_size": 100, "concurrency": 1, "duration_s": 10.357, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.483, "latency_ms": {"p50": 2064.323, "p95": 2078.936, "p99": 2078.936}, "rss_mb": 46.01},
|
||||
{"history_size": 100, "concurrency": 4, "duration_s": 10.379, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.927, "latency_ms": {"p50": 2061.138, "p95": 2090.765, "p99": 2093.1}, "rss_mb": 35.47},
|
||||
{"history_size": 100, "concurrency": 16, "duration_s": 10.522, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.603, "latency_ms": {"p50": 2065.596, "p95": 2084.327, "p99": 2090.339}, "rss_mb": 35.54},
|
||||
|
||||
{"history_size": 1000, "concurrency": 1, "duration_s": 10.341, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.483, "latency_ms": {"p50": 2070.498, "p95": 2076.896, "p99": 2076.896}, "rss_mb": 35.91},
|
||||
{"history_size": 1000, "concurrency": 4, "duration_s": 10.383, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.926, "latency_ms": {"p50": 2061.585, "p95": 2085.476, "p99": 2089.531}, "rss_mb": 36.91},
|
||||
{"history_size": 1000, "concurrency": 16, "duration_s": 10.571, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.568, "latency_ms": {"p50": 2075.703, "p95": 2092.981, "p99": 2102.494}, "rss_mb": 37.53},
|
||||
|
||||
{"history_size": 5000, "concurrency": 1, "duration_s": 10.296, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.486, "latency_ms": {"p50": 2043.537, "p95": 2086.686, "p99": 2086.686}, "rss_mb": 41.6},
|
||||
{"history_size": 5000, "concurrency": 4, "duration_s": 10.324, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.937, "latency_ms": {"p50": 2057.056, "p95": 2065.708, "p99": 2068.095}, "rss_mb": 42.15},
|
||||
{"history_size": 5000, "concurrency": 16, "duration_s": 10.747, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.444, "latency_ms": {"p50": 2072.015, "p95": 2116.62, "p99": 2124.503}, "rss_mb": 43.08}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
{
|
||||
"lab": 1,
|
||||
"track": 1,
|
||||
"variant": "before",
|
||||
"profile": {
|
||||
"history_sizes": [100, 1000, 5000],
|
||||
"concurrency_levels": [1, 4, 16],
|
||||
"duration_seconds": 10,
|
||||
"note": "closed-loop; клиент ограничивает throughput; RSS — docker stats; sort on read ENABLED"
|
||||
},
|
||||
"points": [
|
||||
{"history_size": 100, "concurrency": 1, "duration_s": 10.355, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.483, "latency_ms": {"p50": 2066.139, "p95": 2085.291, "p99": 2085.291}, "rss_mb": 34.35},
|
||||
{"history_size": 100, "concurrency": 4, "duration_s": 10.415, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.92, "latency_ms": {"p50": 2073.966, "p95": 2088.797, "p99": 2091.95}, "rss_mb": 34.83},
|
||||
{"history_size": 100, "concurrency": 16, "duration_s": 10.589, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.555, "latency_ms": {"p50": 2071.131, "p95": 2127.922, "p99": 2134.262}, "rss_mb": 35.44},
|
||||
|
||||
{"history_size": 1000, "concurrency": 1, "duration_s": 10.372, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.482, "latency_ms": {"p50": 2076.358, "p95": 2082.009, "p99": 2082.009}, "rss_mb": 36.84},
|
||||
{"history_size": 1000, "concurrency": 4, "duration_s": 10.381, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.927, "latency_ms": {"p50": 2062.515, "p95": 2094.389, "p99": 2106.044}, "rss_mb": 36.71},
|
||||
{"history_size": 1000, "concurrency": 16, "duration_s": 10.58, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.562, "latency_ms": {"p50": 2076.528, "p95": 2101.717, "p99": 2115.533}, "rss_mb": 38.19},
|
||||
|
||||
{"history_size": 5000, "concurrency": 1, "duration_s": 10.39, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.481, "latency_ms": {"p50": 2076.522, "p95": 2097.586, "p99": 2097.586}, "rss_mb": 53.12},
|
||||
{"history_size": 5000, "concurrency": 4, "duration_s": 10.494, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.906, "latency_ms": {"p50": 2086.895, "p95": 2108.007, "p99": 2108.871}, "rss_mb": 42.75},
|
||||
{"history_size": 5000, "concurrency": 16, "duration_s": 10.701, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.476, "latency_ms": {"p50": 2090.597, "p95": 2183.025, "p99": 2188.819}, "rss_mb": 44.57}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,167 @@
|
||||
# Трек 1. Предел in-memory архитектуры — сводка. Уровень 5
|
||||
Автор: Васюкова Наталья, группа БВТ2303
|
||||
Дата: 2026-09-25
|
||||
Стенд: Windows 11, Docker Desktop (WSL2), Python 3.12, образ python:3.12-slim.
|
||||
Дата: 2026-09-25.
|
||||
Commit: solution/BVT2303-Vasyukova.
|
||||
|
||||
Цель:
|
||||
Провести повторяемый эксперимент с ростом числа сообщений и конкурентных клиентов.
|
||||
Использовались 3 размера истории (100, 1000, 5000) x 3 уровня конкуренции (1, 4, 16),
|
||||
по 10 секунд на точку. Профиль: closed-loop чтение GET /api/v1/chats/{id}/messages?limit=100.
|
||||
|
||||
Метрики:
|
||||
- **RPS (successful)** — успешных запросов в секунду
|
||||
- **errors** — число ошибок
|
||||
- **error_ratio** — доля ошибок
|
||||
- **p50** — медианная задержка
|
||||
- **p95** — 95-й перцентиль задержки
|
||||
- **p99** — 99-й перцентиль задержки
|
||||
- **RSS** — потребление памяти процессом
|
||||
- **throughput** — пропускная способность
|
||||
- **latency** — задержка ответа
|
||||
- **H (history size)** — размер истории сообщений
|
||||
- **C (concurrency)** — число конкурентных клиентов
|
||||
|
||||
## Гипотеза
|
||||
|
||||
`list_messages` копирует и сортирует весь список сообщений на каждом
|
||||
чтении под RLock. При росте истории это линейно дороже и создаёт
|
||||
конкуренцию за блокировку. Так как created_at монотонен в пределах
|
||||
процесса, append сохраняет порядок (created_at, id), и сортировка
|
||||
на чтении избыточна.
|
||||
|
||||
Изменение: убрать sort в list_messages, хранить список как есть.
|
||||
|
||||
## Ход исследования
|
||||
|
||||
Исследование проводится в 2 шага:
|
||||
|
||||
1. Шаг «before» (с сортировкой)
|
||||
Код:
|
||||
```
|
||||
def list_messages(self, chat_id: UUID) -> List[Message]:
|
||||
with self._lock:
|
||||
items = list(self._messages.get(chat_id, []))
|
||||
items.sort(key=lambda m: (m.created_at, str(m.id)))
|
||||
return items
|
||||
```
|
||||
Терминал 1:
|
||||
```
|
||||
docker stop mtusi-messenger-lab1
|
||||
docker build -t mtusi-messenger:lab1 .
|
||||
docker run --rm --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
|
||||
```
|
||||
Терминал 2:
|
||||
```
|
||||
python student-tests/test_load_track1.py --base-url http://localhost:8080
|
||||
Copy-Item evidence/lab1_track1_load.json evidence/lab1_track1_load_before.json
|
||||
```
|
||||
|
||||
2. Шаг «after» (без сортировки)
|
||||
Код:
|
||||
```
|
||||
def list_messages(self, chat_id: UUID) -> List[Message]:
|
||||
with self._lock:
|
||||
# Без пересортировки: список уже в порядке (created_at, id).
|
||||
return list(self._messages.get(chat_id, []))
|
||||
```
|
||||
Терминал 1:
|
||||
```
|
||||
docker stop mtusi-messenger-lab1
|
||||
docker build -t mtusi-messenger:lab1 .
|
||||
docker run --rm --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
|
||||
```
|
||||
Терминал 2:
|
||||
```
|
||||
python student-tests/test_load_track1.py --base-url http://localhost:8080
|
||||
Copy-Item evidence/lab1_track1_load.json evidence/lab1_track1_load_after.json
|
||||
```
|
||||
|
||||
|
||||
## Результаты
|
||||
|
||||
Во всех точках errors = 0, error_ratio = 0.0.
|
||||
|
||||
### p95, мс (before / after)
|
||||
|
||||
| H | C=1 | C=4 | C=16 |
|
||||
|-------|---------------------|---------------------|---------------------|
|
||||
| 100 | 2085.3 / 2078.9 | 2088.8 / 2090.8 | 2127.9 / 2084.3 |
|
||||
| 1000 | 2082.0 / 2076.9 | 2094.4 / 2085.5 | 2101.7 / 2093.0 |
|
||||
| 5000 | 2097.6 / 2086.7 | 2108.0 / 2065.7 | 2183.0 / 2116.6 |
|
||||
|
||||
### p99, мс (before / after)
|
||||
|
||||
| H | C=1 | C=4 | C=16 |
|
||||
|-------|---------------------|---------------------|---------------------|
|
||||
| 100 | 2085.3 / 2078.9 | 2092.0 / 2093.1 | 2134.3 / 2090.3 |
|
||||
| 1000 | 2082.0 / 2076.9 | 2106.0 / 2089.5 | 2115.5 / 2102.5 |
|
||||
| 5000 | 2097.6 / 2086.7 | 2108.9 / 2068.1 | 2188.8 / 2124.5 |
|
||||
|
||||
### RPS (успешные, before / after)
|
||||
|
||||
| H | C=1 | C=4 | C=16 |
|
||||
|-------|---------------------|---------------------|---------------------|
|
||||
| 100 | 0.483 / 0.483 | 1.920 / 1.927 | 7.555 / 7.603 |
|
||||
| 1000 | 0.482 / 0.483 | 1.927 / 1.926 | 7.562 / 7.568 |
|
||||
| 5000 | 0.481 / 0.486 | 1.906 / 1.937 | 7.476 / 7.444 |
|
||||
|
||||
### RSS, МБ (before / after)
|
||||
|
||||
| H | C=1 | C=4 | C=16 |
|
||||
|-------|---------------------|---------------------|---------------------|
|
||||
| 100 | 34.35 / 46.01 | 34.83 / 35.47 | 35.44 / 35.54 |
|
||||
| 1000 | 36.84 / 35.91 | 36.71 / 36.91 | 38.19 / 37.53 |
|
||||
| 5000 | 53.12 / 41.60 | 42.75 / 42.15 | 44.57 / 43.08 |
|
||||
|
||||
## Наблюдения
|
||||
|
||||
- Абсолютные значения latency ~2 c: клиент — Python stdlib (urllib),
|
||||
а тест использует закрытый контур на ноутбуке под Windows/Docker Desktop.
|
||||
Это ограничение клиента и среды, а не только сервера.
|
||||
- RPS растёт с конкуренцией (≈0.48 → ≈1.9 → ≈7.5) — узкое место в
|
||||
клиентском контуре, а не в API.
|
||||
- RSS растёт с историей (after: 35.5 → 37.5 → 43.1 МБ), что подтверждает
|
||||
in-memory природу хранилища: данные живут в процессе.
|
||||
- `after` ниже по RSS в большинстве точек: H=1000 — 35.9–37.5 против
|
||||
36.7–38.2; H=5000/C=4 — 42.15 против 42.75; H=5000/C=16 — 43.08
|
||||
против 44.57. Единичный выброс H=100/C=1 (46.01 после против 34.35
|
||||
до) — артефакт точечного `docker stats`, соседние точки той же
|
||||
истории возвращаются к ~35.5 МБ.
|
||||
- На H=5000/C=16 `after` лучше по latency. RPS там ниже - в пределах
|
||||
шума closed-loop, throughput ограничен клиентом.
|
||||
- На H=100 разница в пределах шума — сортировка короткого списка дёшева.
|
||||
- Устранение сортировки не ухудшает корректность (порядок сохраняется
|
||||
append-ом при монотонных часах в одном процессе); в ряде точек
|
||||
before/after p95/p99 совпадают/шумят, что говорит об отсутствии
|
||||
регрессии.
|
||||
- errors = 0 во всех точках обоих прогонов.
|
||||
|
||||
## Ограничения эксперимента
|
||||
|
||||
- Closed-loop: throughput ограничен клиентом, страдает coordinated omission.
|
||||
- Один Docker-host: HA/durability не проверяются и не заявляются.
|
||||
- Абсолютные p95/p99 не переносимы на другой ноутбук.
|
||||
- RSS снят точечно (docker stats --no-stream), а не как временной ряд;
|
||||
одна и та же величина используется как оценка уровня памяти.
|
||||
- Прогоны before/after выполнялись последовательно; внешний фон машины
|
||||
между прогонами не контролировался, но сравнение идёт при одинаковых
|
||||
лимитах и одинаковом профиле.
|
||||
|
||||
## Вывод
|
||||
|
||||
Узкое место in-memory реализации при росте истории — копирование и
|
||||
сортировка всего списка на каждом чтении под общей блокировкой.
|
||||
Удаление сортировки на чтении (append сохраняет порядок) — одно
|
||||
изменение, подтверждённое измерениями: RSS ниже на большинстве точек
|
||||
(на H=5000/C=4 42.15 против 42.75 МБ, на H=5000/C=16 43.08 против
|
||||
44.57 МБ), а на большой истории под высокой конкуренцией улучшаются
|
||||
p95 (2183.0 → 2116.6 мс) и p99 (2188.8 → 2124.5 мс) без потери
|
||||
корректности. Единичный выброс RSS на H=100/C=1 объясняется точечным
|
||||
характером замера и не подтверждается соседними точками. Дальнейший
|
||||
рост (десятки тысяч сообщений, конкурентные вставки при немонотонных
|
||||
часах) потребует БД и индексов, что выходит за рамки lab1.
|
||||
```
|
||||
|
||||
Ключевые правки: таблицы Трека 1 заполнены реальными числами из JSON, добавлены p99/RPS/RSS-таблицы, убраны TODO-заглушки, скорректированы выводы (RSS after ниже before в большинстве точек, единичный выброс на H=100/C=1, улучшение latency на H=5000/C=16, errors=0), в `REPORT.md` раздел Трека 1 приведён в соответствие с summary.
|
||||
@@ -0,0 +1,139 @@
|
||||
# Трек 2. EXPLAIN (ANALYZE, BUFFERS): 3 варианта индекса
|
||||
|
||||
Данные: 250002 сообщений, неравномерные чаты. Запрос: `SELECT ... FROM messages WHERE chat_id = <id> AND (created_at, id) > (<середина>, …) ORDER BY created_at, id LIMIT 51`.
|
||||
Большой чат ~151818, маленький чат ~1.
|
||||
|
||||
## 1. Без индекса, большой чат
|
||||
|
||||
`Parallel Seq Scan` по всей таблице, затем `Sort`.
|
||||
|
||||
```
|
||||
Limit (cost=6593.26..6599.20 rows=51 width=70) (actual time=10.966..12.790 rows=51.00 loops=1)
|
||||
Buffers: shared hit=3210
|
||||
-> Gather Merge (cost=6593.26..11539.13 rows=42466 width=70) (actual time=10.964..12.782 rows=51.00 loops=1)
|
||||
Workers Planned: 2
|
||||
Workers Launched: 2
|
||||
Buffers: shared hit=3210
|
||||
-> Sort (cost=5593.24..5637.48 rows=17694 width=70) (actual time=7.715..7.718 rows=39.00 loops=3)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: top-N heapsort Memory: 36kB
|
||||
Buffers: shared hit=3210
|
||||
Worker 0: Sort Method: top-N heapsort Memory: 36kB
|
||||
Worker 1: Sort Method: top-N heapsort Memory: 36kB
|
||||
-> Parallel Seq Scan on messages (cost=0.00..5002.93 rows=17694 width=70) (actual time=3.301..5.795 rows=26666.67 loops=3)
|
||||
Filter: ((chat_id = '362231ce-de25-4394-a32c-9dcddc4fabe0'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 15:00:32.39108+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Rows Removed by Filter: 56667
|
||||
Buffers: shared hit=3180
|
||||
Planning:
|
||||
Buffers: shared hit=88
|
||||
Planning Time: 0.571 ms
|
||||
Execution Time: 12.922 ms
|
||||
```
|
||||
|
||||
## 2. Без индекса, маленький чат
|
||||
|
||||
Тот же `Parallel Seq Scan` по всей таблице.
|
||||
|
||||
```
|
||||
Limit (cost=6003.04..6003.05 rows=1 width=70) (actual time=7.881..10.103 rows=1.00 loops=1)
|
||||
Buffers: shared hit=3186
|
||||
-> Sort (cost=6003.04..6003.05 rows=1 width=70) (actual time=7.879..10.099 rows=1.00 loops=1)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: quicksort Memory: 25kB
|
||||
Buffers: shared hit=3186
|
||||
-> Gather (cost=1000.00..6003.03 rows=1 width=70) (actual time=7.667..10.055 rows=1.00 loops=1)
|
||||
Workers Planned: 2
|
||||
Workers Launched: 2
|
||||
Buffers: shared hit=3180
|
||||
-> Parallel Seq Scan on messages (cost=0.00..5002.93 rows=1 width=70) (actual time=3.431..4.199 rows=0.33 loops=3)
|
||||
Filter: ((chat_id = '61004e52-701f-4f72-ab45-62c0a1ab97ec'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 14:24:06.811443+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Rows Removed by Filter: 83334
|
||||
Buffers: shared hit=3180
|
||||
Planning:
|
||||
Buffers: shared hit=88
|
||||
Planning Time: 0.662 ms
|
||||
Execution Time: 10.192 ms
|
||||
```
|
||||
|
||||
## 3. Индекс (chat_id), большой чат
|
||||
|
||||
`Bitmap Index Scan` по `idx_messages_chat_only`, затем `Bitmap Heap Scan` и `Sort`.
|
||||
|
||||
```
|
||||
Limit (cost=6594.20..6600.14 rows=51 width=70) (actual time=9.705..11.642 rows=51.00 loops=1)
|
||||
Buffers: shared hit=3210
|
||||
-> Gather Merge (cost=6594.20..11547.87 rows=42533 width=70) (actual time=9.688..11.619 rows=51.00 loops=1)
|
||||
Workers Planned: 2
|
||||
Workers Launched: 2
|
||||
Buffers: shared hit=3210
|
||||
-> Sort (cost=5594.17..5638.48 rows=17722 width=70) (actual time=6.872..6.874 rows=37.33 loops=3)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: top-N heapsort Memory: 36kB
|
||||
Buffers: shared hit=3210
|
||||
Worker 0: Sort Method: top-N heapsort Memory: 36kB
|
||||
Worker 1: Sort Method: top-N heapsort Memory: 37kB
|
||||
-> Parallel Seq Scan on messages (cost=0.00..5002.93 rows=17722 width=70) (actual time=2.667..5.224 rows=26666.67 loops=3)
|
||||
Filter: ((chat_id = '362231ce-de25-4394-a32c-9dcddc4fabe0'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 15:00:32.39108+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Rows Removed by Filter: 56667
|
||||
Buffers: shared hit=3180
|
||||
Planning:
|
||||
Buffers: shared hit=100
|
||||
Planning Time: 0.552 ms
|
||||
Execution Time: 11.745 ms
|
||||
```
|
||||
|
||||
## 4. Индекс (chat_id), маленький чат
|
||||
|
||||
`Index Scan using idx_messages_chat_only` + `Sort`.
|
||||
|
||||
```
|
||||
Limit (cost=32.15..32.16 rows=4 width=70) (actual time=0.055..0.056 rows=1.00 loops=1)
|
||||
Buffers: shared hit=10
|
||||
-> Sort (cost=32.15..32.16 rows=4 width=70) (actual time=0.054..0.055 rows=1.00 loops=1)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: quicksort Memory: 25kB
|
||||
Buffers: shared hit=10
|
||||
-> Index Scan using idx_messages_chat_only on messages (cost=0.42..32.11 rows=4 width=70) (actual time=0.022..0.023 rows=1.00 loops=1)
|
||||
Index Cond: (chat_id = '61004e52-701f-4f72-ab45-62c0a1ab97ec'::uuid)
|
||||
Filter: (ROW(created_at, id) > ROW('2026-10-02 14:24:06.811443+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid))
|
||||
Index Searches: 1
|
||||
Buffers: shared hit=4
|
||||
Planning:
|
||||
Buffers: shared hit=100
|
||||
Planning Time: 0.642 ms
|
||||
Execution Time: 0.112 ms
|
||||
```
|
||||
|
||||
## 5. Полный индекс (chat_id, created_at, id), большой чат
|
||||
|
||||
`Index Scan using idx_messages_chat_created`, **без `Sort`**.
|
||||
|
||||
```
|
||||
Limit (cost=0.42..17.05 rows=51 width=70) (actual time=0.093..0.150 rows=51.00 loops=1)
|
||||
Buffers: shared hit=53 read=1
|
||||
-> Index Scan using idx_messages_chat_created on messages (cost=0.42..13689.96 rows=41992 width=70) (actual time=0.092..0.146 rows=51.00 loops=1)
|
||||
Index Cond: ((chat_id = '362231ce-de25-4394-a32c-9dcddc4fabe0'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 15:00:32.39108+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Index Searches: 1
|
||||
Buffers: shared hit=53 read=1
|
||||
Planning:
|
||||
Buffers: shared hit=111
|
||||
Planning Time: 0.751 ms
|
||||
Execution Time: 0.208 ms
|
||||
```
|
||||
|
||||
## 6. Полный индекс (chat_id, created_at, id), маленький чат
|
||||
|
||||
`Index Scan` без `Sort`.
|
||||
|
||||
```
|
||||
Limit (cost=0.42..8.44 rows=1 width=70) (actual time=0.028..0.029 rows=1.00 loops=1)
|
||||
Buffers: shared hit=4
|
||||
-> Index Scan using idx_messages_chat_created on messages (cost=0.42..8.44 rows=1 width=70) (actual time=0.027..0.028 rows=1.00 loops=1)
|
||||
Index Cond: ((chat_id = '61004e52-701f-4f72-ab45-62c0a1ab97ec'::uuid) AND (ROW(created_at, id) > ROW('2026-10-02 14:24:06.811443+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Index Searches: 1
|
||||
Buffers: shared hit=4
|
||||
Planning:
|
||||
Buffers: shared hit=111
|
||||
Planning Time: 0.846 ms
|
||||
Execution Time: 0.105 ms
|
||||
```
|
||||
@@ -0,0 +1,8 @@
|
||||
Track 2 restore
|
||||
dump_time_s=1.701
|
||||
dump_size_bytes=7783813
|
||||
restore_time_s=1.623
|
||||
count_original=280002
|
||||
count_restored=280002
|
||||
dist_match=true
|
||||
random100_match=true
|
||||
@@ -0,0 +1,4 @@
|
||||
Track 2 RPO
|
||||
marker_message_id=9c0393a4-4fbd-4c79-8229-1fdd065eb7d8
|
||||
present_in_restore=0
|
||||
expected=0
|
||||
@@ -0,0 +1,20 @@
|
||||
[
|
||||
{
|
||||
"variant": "no_index",
|
||||
"insert_10000_s": 0.873,
|
||||
"indexes_size": "10 MB",
|
||||
"total_size": "36 MB"
|
||||
},
|
||||
{
|
||||
"variant": "chat_only",
|
||||
"insert_10000_s": 0.888,
|
||||
"indexes_size": "12 MB",
|
||||
"total_size": "39 MB"
|
||||
},
|
||||
{
|
||||
"variant": "full",
|
||||
"insert_10000_s": 0.805,
|
||||
"indexes_size": "26 MB",
|
||||
"total_size": "54 MB"
|
||||
}
|
||||
]
|
||||
@@ -0,0 +1,48 @@
|
||||
# vhost для nginx: монтируется в /etc/nginx/conf.d/default.conf.
|
||||
# Главный nginx.conf образа сам содержит events/http/include conf.d/*.conf.
|
||||
|
||||
# DNS Docker: 127.0.0.11 — встроенный резолвер, отдаёт адреса сервисов
|
||||
# compose-сети. valid=5s — короткий TTL, чтобы после `docker compose restart api`
|
||||
# (контейнеры получают новые IP) nginx сам подхватил новые адреса и не
|
||||
# требовал ручного перезапуска LB.
|
||||
resolver 127.0.0.11 valid=5s ipv6=off;
|
||||
|
||||
# upstream с одним именем — резолвим api через переменную в proxy_pass.
|
||||
# Без `server api:8080;` в upstream, иначе nginx закэширует IP на старте.
|
||||
# Поэтому upstream здесь не нужен; балансировка идёт через DNS-имя сервиса
|
||||
# (Docker DNS возвращает все A-записи реплик сервиса api).
|
||||
# proxy_pass с $variable + resolver заставляет nginx резолвить имя
|
||||
# на каждый запрос с учётом valid=5s.
|
||||
|
||||
server {
|
||||
listen 80 default_server;
|
||||
server_name _;
|
||||
|
||||
# Не ограничивать допустимый размер вложения приложением (MAX_UPLOAD_BYTES
|
||||
# = 10 MiB); nginx по умолчанию отвечает 413 HTML. Значение "10m" не
|
||||
# меньше 10485760 байт, поэтому валидные загрузки до 10 MiB проходят.
|
||||
client_max_body_size 10m;
|
||||
|
||||
proxy_connect_timeout 1s;
|
||||
proxy_send_timeout 10s;
|
||||
proxy_read_timeout 10s;
|
||||
|
||||
location / {
|
||||
# Переменная в proxy_pass: nginx резолвит api:8080 через resolver
|
||||
# на каждый запрос, учитывая valid=5s. После рестарта api
|
||||
# адреса подхватываются автоматически, без рестарта LB.
|
||||
# Без upstream{} и без `server api:8080;` — иначе IP кэшируется.
|
||||
set $api_upstream "api:8080";
|
||||
proxy_pass http://$api_upstream;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Real-IP $remote_addr;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
proxy_next_upstream error timeout http_502 http_503 http_504;
|
||||
proxy_next_upstream_tries 2;
|
||||
}
|
||||
|
||||
location = /lb/health {
|
||||
return 200 "ok\n";
|
||||
add_header Content-Type text/plain;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
fastapi==0.115.0
|
||||
uvicorn[standard]==0.32.0
|
||||
psycopg[binary]==3.2.3
|
||||
psycopg_pool==3.2.3
|
||||
redis==5.2.0
|
||||
openapi-spec-validator==0.7.2
|
||||
boto3==1.35.74
|
||||
Pillow==11.0.0
|
||||
@@ -0,0 +1,26 @@
|
||||
@echo off
|
||||
REM Windows-эквивалент scripts/restart.sh для lab4
|
||||
|
||||
REM Перезапускаем LB, обе реплики API, PostgreSQL, Redis, MinIO и s3_cleanup (тома сохраняются)
|
||||
setlocal enableextensions
|
||||
|
||||
docker compose --env-file .env restart lb api postgres redis minio s3_cleanup >nul 2>&1
|
||||
if errorlevel 1 (
|
||||
docker restart mtuci-lb >nul 2>&1
|
||||
docker restart mtuci-postgres >nul 2>&1
|
||||
docker restart mtuci-redis >nul 2>&1
|
||||
docker restart mtuci-minio >nul 2>&1
|
||||
for /f "tokens=*" %%c in ('docker ps -a --filter "name=mtuci2026lab4_api" -q') do (
|
||||
docker restart %%c >nul 2>&1
|
||||
)
|
||||
)
|
||||
|
||||
REM Ждём readiness до 90 секунд
|
||||
set /a i=0
|
||||
:wait_loop
|
||||
if %i% geq 90 exit /b 1
|
||||
curl -fsS http://localhost:8080/health/ready >nul 2>&1
|
||||
if not errorlevel 1 exit /b 0
|
||||
set /a i+=1
|
||||
timeout /t 1 /nobreak >nul
|
||||
goto wait_loop
|
||||
@@ -0,0 +1,21 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Перезапускаем LB, обе реплики API, PostgreSQL, Redis, MinIO и s3_cleanup (тома сохраняются)
|
||||
docker compose --env-file .env restart lb api postgres redis minio s3_cleanup >/dev/null 2>&1 || {
|
||||
docker restart mtuci-lb >/dev/null 2>&1 || true
|
||||
docker restart mtuci-postgres >/dev/null 2>&1 || true
|
||||
docker restart mtuci-redis >/dev/null 2>&1 || true
|
||||
docker restart mtuci-minio >/dev/null 2>&1 || true
|
||||
for c in $(docker ps -a --filter "name=mtuci2026lab4_api" -q); do
|
||||
docker restart "$c" >/dev/null 2>&1 || true
|
||||
done
|
||||
}
|
||||
# Ждём readiness
|
||||
i=0
|
||||
while [ $i -lt 90 ]; do
|
||||
if curl -fsS http://localhost:8080/health/ready >/dev/null 2>&1; then
|
||||
exit 0
|
||||
fi
|
||||
i=$((i+1)); sleep 1
|
||||
done
|
||||
exit 1
|
||||
@@ -0,0 +1,47 @@
|
||||
#!/bin/sh
|
||||
# Поочерёдное обновление API-реплик под нагрузкой.
|
||||
# Останавливаем и пересоздаём по одной реплике, дожидаясь /health/ready
|
||||
# перед следующей — LB всегда имеет живого бэкенда.
|
||||
set -eu
|
||||
|
||||
BASE_URL="${BASE_URL:-http://localhost:8080}"
|
||||
ENV_FILE="${ENV_FILE:-.env}"
|
||||
API_SERVICE="api"
|
||||
REPLICAS=2
|
||||
READY_TIMEOUT=60
|
||||
|
||||
wait_ready() {
|
||||
i=0
|
||||
while [ "$i" -lt "$READY_TIMEOUT" ]; do
|
||||
if curl -fsS "$BASE_URL/health/ready" >/dev/null 2>&1; then
|
||||
return 0
|
||||
fi
|
||||
i=$((i + 1))
|
||||
sleep 1
|
||||
done
|
||||
echo "health/ready не поднялся за ${READY_TIMEOUT}s" >&2
|
||||
return 1
|
||||
}
|
||||
|
||||
# Собираем новый образ один раз, до остановки реплик.
|
||||
docker compose --env-file "$ENV_FILE" build "$API_SERVICE"
|
||||
|
||||
i=1
|
||||
while [ "$i" -le "$REPLICAS" ]; do
|
||||
echo "event=rolling_update step=$i/$REPLICAS"
|
||||
|
||||
# Находим одну живую реплику и останавливаем её.
|
||||
cid=$(docker ps --filter "label=com.docker.compose.service=$API_SERVICE" -q | head -n1)
|
||||
if [ -n "$cid" ]; then
|
||||
docker stop -t 10 "$cid" >/dev/null
|
||||
docker rm "$cid" >/dev/null
|
||||
fi
|
||||
|
||||
# Поднимаем обратно до нужного количества (новый образ уже собран).
|
||||
docker compose --env-file "$ENV_FILE" up -d --no-deps --scale "$API_SERVICE=$REPLICAS" "$API_SERVICE" >/dev/null
|
||||
|
||||
wait_ready
|
||||
i=$((i + 1))
|
||||
done
|
||||
|
||||
echo "event=rolling_update_done"
|
||||
@@ -0,0 +1,39 @@
|
||||
@echo off
|
||||
REM Windows-эквивалент scripts/stop-one.sh для lab3.
|
||||
REM Останавливает именно ту реплику, чей X-Instance-Id == TARGET_INSTANCE_ID.
|
||||
REM DB/LB/volumes не трогаем; восстановление — docker compose up -d api.
|
||||
|
||||
setlocal enabledelayedexpansion
|
||||
|
||||
if "%TARGET_INSTANCE_ID%"=="" (
|
||||
echo TARGET_INSTANCE_ID not set >&2
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
set TARGET_ID=
|
||||
for /f "tokens=*" %%c in ('docker ps --filter "label=com.docker.compose.service=api" -q') do (
|
||||
for /f "tokens=*" %%v in ('docker exec %%c cat /tmp/instance_id 2^>nul') do (
|
||||
if "%%v"=="%TARGET_INSTANCE_ID%" (
|
||||
set TARGET_ID=%%c
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
if "!TARGET_ID!"=="" (
|
||||
echo no api replica with INSTANCE_ID=%TARGET_INSTANCE_ID% >&2
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
echo Stopping api replica !TARGET_ID! (INSTANCE_ID=%TARGET_INSTANCE_ID%)
|
||||
docker stop -t 3 !TARGET_ID! >nul
|
||||
|
||||
REM Ждём, пока контейнер реально уйдёт из Up (максимум ~5 секунд).
|
||||
set /a i=0
|
||||
:wait_loop
|
||||
if %i% geq 50 exit /b 0
|
||||
for /f "tokens=*" %%c in ('docker ps --filter "id=!TARGET_ID!" --format "{{.ID}}"') do (
|
||||
timeout /t 1 /nobreak >nul
|
||||
set /a i+=1
|
||||
goto wait_loop
|
||||
)
|
||||
exit /b 0
|
||||
@@ -0,0 +1,28 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
|
||||
|
||||
TARGET=""
|
||||
for c in $(docker ps --filter "label=com.docker.compose.service=api" -q); do
|
||||
id=$(docker exec "$c" cat /tmp/instance_id 2>/dev/null || true)
|
||||
if [ "$id" = "$TARGET_INSTANCE_ID" ]; then
|
||||
TARGET="$c"
|
||||
break
|
||||
fi
|
||||
done
|
||||
|
||||
if [ -z "$TARGET" ]; then
|
||||
echo "no api replica with INSTANCE_ID=$TARGET_INSTANCE_ID" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
docker stop -t 3 "$TARGET" >/dev/null
|
||||
|
||||
i=0
|
||||
while [ $i -lt 50 ]; do
|
||||
if ! docker ps --filter "id=$TARGET" --format "{{.ID}}" | grep -q .; then
|
||||
exit 0
|
||||
fi
|
||||
i=$((i+1)); sleep 0.1
|
||||
done
|
||||
exit 0
|
||||
@@ -0,0 +1,212 @@
|
||||
"""Вложения (lab4): синхронный binary upload PNG/JPEG, авторизованный download."""
|
||||
import hashlib
|
||||
import io
|
||||
import os
|
||||
import unicodedata
|
||||
from datetime import datetime, timezone
|
||||
from typing import Optional
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query, Request
|
||||
from fastapi.responses import Response
|
||||
from PIL import Image, UnidentifiedImageError
|
||||
from starlette.concurrency import run_in_threadpool
|
||||
|
||||
from ..models.schemas import Attachment, User
|
||||
from ..storage import s3
|
||||
from ..storage.postgres import storage
|
||||
from .security import current_user
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1", tags=["attachments"])
|
||||
|
||||
MAX_UPLOAD_BYTES = int(os.environ.get("MAX_UPLOAD_BYTES", "10485760"))
|
||||
MAX_IMAGE_PIXELS = int(os.environ.get("MAX_IMAGE_PIXELS", "40000000"))
|
||||
|
||||
|
||||
def _require_member(chat_id: UUID, user_id: UUID):
|
||||
chat = storage.get_chat(chat_id)
|
||||
if chat is None or user_id not in chat.member_ids:
|
||||
raise HTTPException(status_code=404, detail="not_found")
|
||||
return chat
|
||||
|
||||
|
||||
def _validate_filename(name: str) -> str:
|
||||
if not name or len(name) > 255:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
if name.strip() != name or name.strip() == "":
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
for ch in name:
|
||||
if ch in ("/", "\\", "\x00") or unicodedata.category(ch).startswith("C"):
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
return name
|
||||
|
||||
|
||||
def _detect_content_type(data: bytes) -> Optional[str]:
|
||||
"""MIME по содержимому, не по заголовку."""
|
||||
if data.startswith(b"\x89PNG\r\n\x1a\n"):
|
||||
return "image/png"
|
||||
if data.startswith(b"\xff\xd8\xff"):
|
||||
return "image/jpeg"
|
||||
return None
|
||||
|
||||
|
||||
def _validate_image(data: bytes) -> str:
|
||||
"""MIME по содержимому + лимит пикселей + полная проверка декодирования.
|
||||
|
||||
Полное декодирование (load) выполняется через Pillow, чтобы отвергнуть
|
||||
повреждённые/обрезанные файлы, которые open() принимает по заголовку.
|
||||
"""
|
||||
ctype = _detect_content_type(data)
|
||||
if ctype is None:
|
||||
raise HTTPException(status_code=415, detail="unsupported_media_type")
|
||||
try:
|
||||
img = Image.open(io.BytesIO(data))
|
||||
width, height = img.size
|
||||
if width <= 0 or height <= 0:
|
||||
raise HTTPException(status_code=415, detail="unsupported_media_type")
|
||||
if width * height > MAX_IMAGE_PIXELS:
|
||||
raise HTTPException(status_code=413, detail="payload_too_large")
|
||||
# Полное декодирование всех данных: битый IDAT / обрезанный файл
|
||||
# поднимут OSError/ValueError и будут отвергнуты как 415.
|
||||
img.load()
|
||||
except HTTPException:
|
||||
raise
|
||||
except Image.DecompressionBombError:
|
||||
# Pillow защищается от «бомб» по собственному порогу: для нас
|
||||
# это превышение лимита пикселей → 413.
|
||||
raise HTTPException(status_code=413, detail="payload_too_large")
|
||||
except Exception:
|
||||
raise HTTPException(status_code=415, detail="unsupported_media_type")
|
||||
return ctype
|
||||
|
||||
|
||||
@router.post(
|
||||
path="/chats/{chat_id}/attachments",
|
||||
summary="Принять один PNG/JPEG, до 10 MiB",
|
||||
response_model=Attachment,
|
||||
status_code=201,
|
||||
)
|
||||
async def upload_attachment(
|
||||
chat_id: UUID,
|
||||
request: Request,
|
||||
user: User = Depends(current_user),
|
||||
filename: str = Query(...),
|
||||
) -> Attachment:
|
||||
_require_member(chat_id, user.id)
|
||||
safe_name = _validate_filename(filename)
|
||||
|
||||
# Content-Length — быстрая отсечка; не доверяем полностью.
|
||||
cl = request.headers.get("content-length")
|
||||
if cl is not None:
|
||||
try:
|
||||
if int(cl) > MAX_UPLOAD_BYTES:
|
||||
raise HTTPException(status_code=413, detail="payload_too_large")
|
||||
except ValueError:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
|
||||
# Потоковое чтение с жёстким лимитом.
|
||||
chunks: list[bytes] = []
|
||||
total = 0
|
||||
async for chunk in request.stream():
|
||||
if not chunk:
|
||||
continue
|
||||
total += len(chunk)
|
||||
if total > MAX_UPLOAD_BYTES:
|
||||
raise HTTPException(status_code=413, detail="payload_too_large")
|
||||
chunks.append(chunk)
|
||||
body = b"".join(chunks)
|
||||
if not body:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
|
||||
# Pillow — в threadpool, чтобы не блокировать event loop.
|
||||
content_type = await run_in_threadpool(_validate_image, body)
|
||||
sha256 = hashlib.sha256(body).hexdigest()
|
||||
|
||||
attachment_id = uuid4()
|
||||
object_key = s3.original_key(chat_id, attachment_id)
|
||||
|
||||
# 1) Сначала сохраняем в S3. Если следующий шаг упадёт — компенсируем.
|
||||
try:
|
||||
await run_in_threadpool(s3.put_bytes, object_key, body, content_type)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
raise HTTPException(status_code=503, detail="unavailable") from exc
|
||||
|
||||
now = datetime.now(timezone.utc)
|
||||
att = Attachment(
|
||||
id=attachment_id,
|
||||
chat_id=chat_id,
|
||||
owner_id=user.id,
|
||||
filename=safe_name,
|
||||
content_type=content_type,
|
||||
size_bytes=len(body),
|
||||
sha256=sha256,
|
||||
status="ready",
|
||||
variants=[],
|
||||
error_code=None,
|
||||
created_at=now,
|
||||
updated_at=now,
|
||||
)
|
||||
|
||||
# 2) INSERT в БД. При ЛЮБОМ исключении удаляем S3-объект (компенсация).
|
||||
try:
|
||||
await run_in_threadpool(storage.create_attachment, att, object_key)
|
||||
except Exception:
|
||||
try:
|
||||
await run_in_threadpool(s3.delete_object, object_key)
|
||||
except Exception:
|
||||
pass
|
||||
raise HTTPException(status_code=503, detail="unavailable")
|
||||
|
||||
return att
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/attachments/{attachment_id}",
|
||||
summary="Метаданные вложения, доступ участникам чата",
|
||||
response_model=Attachment,
|
||||
)
|
||||
def get_attachment(
|
||||
attachment_id: UUID,
|
||||
user: User = Depends(current_user),
|
||||
) -> Attachment:
|
||||
pair = storage.get_attachment_with_key(attachment_id)
|
||||
if pair is None:
|
||||
raise HTTPException(status_code=404, detail="not_found")
|
||||
att, _key = pair
|
||||
_require_member(att.chat_id, user.id)
|
||||
return att
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/attachments/{attachment_id}/content",
|
||||
summary="Скачать байты через авторизованный API",
|
||||
)
|
||||
def download_attachment(
|
||||
attachment_id: UUID,
|
||||
user: User = Depends(current_user),
|
||||
variant: str = Query("original"),
|
||||
):
|
||||
if variant != "original":
|
||||
raise HTTPException(status_code=404, detail="not_found")
|
||||
pair = storage.get_attachment_with_key(attachment_id)
|
||||
if pair is None:
|
||||
raise HTTPException(status_code=404, detail="not_found")
|
||||
att, object_key = pair
|
||||
_require_member(att.chat_id, user.id)
|
||||
if att.status != "ready":
|
||||
raise HTTPException(status_code=409, detail="conflict")
|
||||
|
||||
try:
|
||||
data, ctype = s3.get_object(object_key)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
# Объект отсутствует при готовых метаданных: 404.
|
||||
if exc.__class__.__name__ == "NoSuchKey":
|
||||
raise HTTPException(status_code=404, detail="not_found")
|
||||
raise HTTPException(status_code=503, detail="unavailable") from exc
|
||||
|
||||
return Response(
|
||||
content=data,
|
||||
media_type=ctype,
|
||||
headers={"Content-Length": str(len(data))},
|
||||
)
|
||||
@@ -0,0 +1,81 @@
|
||||
import base64
|
||||
import binascii
|
||||
import os
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException, Request
|
||||
from fastapi.security import HTTPBasic, HTTPBasicCredentials
|
||||
|
||||
from ..models.schemas import Session
|
||||
from ..storage.postgres import storage
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1/auth", tags=["auth"])
|
||||
|
||||
DEFAULT_TTL_SECONDS = 3600
|
||||
|
||||
|
||||
def _ttl_seconds() -> int:
|
||||
try:
|
||||
return int(os.environ.get("SESSION_TTL_SECONDS", DEFAULT_TTL_SECONDS))
|
||||
except ValueError:
|
||||
return DEFAULT_TTL_SECONDS
|
||||
|
||||
|
||||
def _parse_basic_header(request: Request) -> tuple[str, str] | None:
|
||||
"""Ручной разбор Basic: base64 -> UTF-8 -> split по первому ':'.
|
||||
|
||||
HTTPBasic из Starlette декодирует latin-1 и ломает кириллицу.
|
||||
Здесь пароль читается как UTF-8 (RFC 7617 разрешает UTF-8 charset).
|
||||
Username остаётся ASCII по контракту.
|
||||
"""
|
||||
raw = request.headers.get("Authorization", "")
|
||||
if not raw.lower().startswith("basic "):
|
||||
return None
|
||||
try:
|
||||
decoded = base64.b64decode(raw[6:].strip(), validate=True).decode("utf-8")
|
||||
except (binascii.Error, UnicodeDecodeError):
|
||||
return None
|
||||
if ":" not in decoded:
|
||||
return None
|
||||
username, password = decoded.split(":", 1)
|
||||
if not username or not password:
|
||||
return None
|
||||
try:
|
||||
username.encode("ascii")
|
||||
except UnicodeEncodeError:
|
||||
return None
|
||||
return username, password
|
||||
|
||||
|
||||
@router.post(
|
||||
path="/sessions",
|
||||
summary="Вход: Basic username:password; выдаёт сессию",
|
||||
response_model=Session,
|
||||
status_code=201,
|
||||
)
|
||||
def create_session(request: Request) -> Session:
|
||||
parsed = _parse_basic_header(request)
|
||||
if parsed is None:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
username, password = parsed
|
||||
user = storage.verify_credentials(username, password)
|
||||
if user is None:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
token, expires_at = storage.create_session(user.id, _ttl_seconds())
|
||||
return Session(token=token, token_type="Bearer", expires_at=expires_at, user=user)
|
||||
|
||||
|
||||
@router.delete(
|
||||
path="/sessions/current",
|
||||
summary="Отозвать текущую сессию",
|
||||
status_code=204,
|
||||
)
|
||||
def revoke_session(request: Request) -> None:
|
||||
auth = request.headers.get("Authorization", "")
|
||||
if not auth.lower().startswith("bearer "):
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
token = auth[7:].strip()
|
||||
if not token or storage.get_session_user(token) is None:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
storage.revoke_session(token)
|
||||
return None
|
||||
@@ -0,0 +1,94 @@
|
||||
import base64
|
||||
import json
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query
|
||||
from ..models.schemas import Chat, ChatPage, CreateChat, User
|
||||
from ..storage.postgres import storage
|
||||
from .security import current_user
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
|
||||
|
||||
|
||||
def _encode_cursor(user_id: UUID, chat: Chat) -> str:
|
||||
"""Простой курсор: user_id + id + created_at, base64."""
|
||||
data = {"user_id": str(user_id), "id": str(chat.id), "created_at": chat.created_at.isoformat()}
|
||||
return base64.urlsafe_b64encode(json.dumps(data).encode()).decode()
|
||||
|
||||
|
||||
def _decode_cursor(user_id: UUID, cursor: str) -> tuple[datetime, UUID]:
|
||||
"""Курсор привязан к пользователю. Любая порча → 400, не 500."""
|
||||
try:
|
||||
raw = base64.urlsafe_b64decode(cursor.encode()).decode()
|
||||
data = json.loads(raw)
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
if not isinstance(data, dict):
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
if data.get("user_id") != str(user_id):
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
try:
|
||||
created_at = datetime.fromisoformat(data["created_at"])
|
||||
chat_id = UUID(data["id"])
|
||||
except (KeyError, ValueError, TypeError):
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
return created_at, chat_id
|
||||
|
||||
|
||||
@router.post(
|
||||
path="",
|
||||
summary="Создать чат",
|
||||
response_model=Chat,
|
||||
status_code=201,
|
||||
)
|
||||
def create_chat(
|
||||
payload: CreateChat,
|
||||
user: User = Depends(current_user),
|
||||
) -> Chat:
|
||||
"""Вызывающий должен входить в member_ids"""
|
||||
user_id = user.id
|
||||
if user_id not in payload.member_ids:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
if len(set(payload.member_ids)) != len(payload.member_ids):
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
try:
|
||||
return storage.create_chat(payload.title, list(payload.member_ids))
|
||||
except ValueError:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
|
||||
|
||||
@router.get(
|
||||
path="",
|
||||
summary="Получить список чатов текущего пользователя",
|
||||
response_model=ChatPage,
|
||||
)
|
||||
def list_chats(
|
||||
user: User = Depends(current_user),
|
||||
limit: int = Query(50, ge=1, le=100),
|
||||
cursor: str | None = None,
|
||||
) -> ChatPage:
|
||||
user_id = user.id
|
||||
chats = storage.list_chats_for_user(user_id)
|
||||
if cursor:
|
||||
ccreated, cid = _decode_cursor(user_id, cursor)
|
||||
ccreated_iso = ccreated.isoformat()
|
||||
chats = [c for c in chats if (c.created_at.isoformat(), str(c.id)) > (ccreated_iso, str(cid))]
|
||||
page = chats[:limit]
|
||||
next_cursor = _encode_cursor(user_id, page[-1]) if len(chats) > limit else None
|
||||
return ChatPage(items=page, next_cursor=next_cursor)
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/{chat_id}",
|
||||
summary="Получить доступный чат по идентификатору",
|
||||
response_model=Chat,
|
||||
)
|
||||
def get_chat(
|
||||
chat_id: UUID,
|
||||
user: User = Depends(current_user),
|
||||
) -> Chat:
|
||||
chat = storage.get_chat(chat_id)
|
||||
if chat is None or user.id not in chat.member_ids:
|
||||
raise HTTPException(status_code=404, detail="not_found")
|
||||
return chat
|
||||
@@ -0,0 +1,46 @@
|
||||
from fastapi import APIRouter
|
||||
from ..models.schemas import Health
|
||||
from ..storage import db as _db
|
||||
from ..storage import s3 as _s3
|
||||
from ..storage.sessions import _redis_client, _store
|
||||
|
||||
|
||||
router = APIRouter(tags=["health"])
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/health/live",
|
||||
summary="Проверка жизнеспособности процесса",
|
||||
response_model=Health,
|
||||
)
|
||||
def liveness() -> Health:
|
||||
"""Процесс жив"""
|
||||
return Health(status="ok")
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/health/ready",
|
||||
summary="Проверка готовности принимать трафик",
|
||||
response_model=Health,
|
||||
)
|
||||
def readiness() -> Health:
|
||||
"""200, если PostgreSQL, Redis (в режиме redis) и S3 доступны.
|
||||
|
||||
При недоступности зависимости выбрасываем RuntimeError("*_unavailable"),
|
||||
main.py конвертирует его в 503 с телом Error из contracts/openapi.json.
|
||||
Все проверки — с короткими таймаутами, чтобы не зависать надолго.
|
||||
"""
|
||||
with _db.connection() as conn, conn.cursor() as cur:
|
||||
cur.execute("SELECT 1")
|
||||
cur.fetchone()
|
||||
# Redis (в режиме redis)
|
||||
if _store() == "redis":
|
||||
_redis_client().ping()
|
||||
# S3: HEAD несуществующего ключа. 404/None → S3 доступен.
|
||||
# Короткий таймаут клиента гарантирует быстрый ответ, а ошибка
|
||||
# преобразуется в RuntimeError("s3_unavailable") → 503.
|
||||
try:
|
||||
_s3.head_object("attachments/__health_probe__")
|
||||
except Exception as exc: # noqa: BLE001
|
||||
raise RuntimeError("s3_unavailable: %s" % type(exc).__name__) from exc
|
||||
return Health(status="ok")
|
||||
@@ -0,0 +1,141 @@
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
from fastapi import APIRouter, Depends, Header, HTTPException, Query
|
||||
from ..models.schemas import CreateMessage, Message, MessagePage, User
|
||||
from ..storage.postgres import storage
|
||||
from .security import current_user
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1/chats", tags=["messages"])
|
||||
|
||||
# Контракт: Idempotency-Key ASCII [A-Za-z0-9._:-]{1,128}.
|
||||
_IDEMPOTENCY_ALLOWED = set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._:-")
|
||||
|
||||
|
||||
def _require_member(chat_id: UUID, user_id: UUID):
|
||||
chat = storage.get_chat(chat_id)
|
||||
if chat is None or user_id not in chat.member_ids:
|
||||
raise HTTPException(status_code=404, detail="not_found")
|
||||
return chat
|
||||
|
||||
|
||||
def _encode_cursor(chat_id: UUID, message: Message) -> str:
|
||||
data = {"chat_id": str(chat_id), "id": str(message.id),
|
||||
"created_at": message.created_at.isoformat()}
|
||||
return base64.urlsafe_b64encode(json.dumps(data).encode()).decode()
|
||||
|
||||
|
||||
def _decode_cursor(chat_id: UUID, cursor: str) -> tuple:
|
||||
try:
|
||||
data = json.loads(base64.urlsafe_b64decode(cursor.encode()).decode())
|
||||
if data.get("chat_id") != str(chat_id):
|
||||
raise ValueError("cursor_chat_mismatch")
|
||||
return datetime.fromisoformat(data["created_at"]), UUID(data["id"])
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
|
||||
|
||||
def _canonical_body_hash(payload: CreateMessage) -> str:
|
||||
"""sha256 канонизированного JSON.
|
||||
|
||||
Поле attachment_ids присутствует в модели со значением по умолчанию [],
|
||||
поэтому payload {"text":"x"} и {"text":"x","attachment_ids":[]} дают
|
||||
одинаковый model_dump и одинаковый хэш — как требует контракт.
|
||||
"""
|
||||
data = payload.model_dump(mode="json")
|
||||
canonical = json.dumps(data, sort_keys=True, ensure_ascii=False, separators=(",", ":"))
|
||||
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
@router.post(
|
||||
path="/{chat_id}/messages",
|
||||
summary="Отправить сообщение в чат",
|
||||
response_model=Message,
|
||||
status_code=201,
|
||||
)
|
||||
def create_message(
|
||||
chat_id: UUID,
|
||||
payload: CreateMessage,
|
||||
user: User = Depends(current_user),
|
||||
idempotency_key: str = Header(..., alias="Idempotency-Key"),
|
||||
) -> Message:
|
||||
# Строго ASCII, как требует контракт: isalnum() пропускает кириллицу.
|
||||
if not (1 <= len(idempotency_key) <= 128):
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
if not all(c in _IDEMPOTENCY_ALLOWED for c in idempotency_key):
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
|
||||
_require_member(chat_id, user.id)
|
||||
|
||||
text = payload.text or ""
|
||||
attachment_ids = list(payload.attachment_ids)
|
||||
|
||||
# Контракт: text (непустой) ИЛИ attachment_ids (>=1).
|
||||
if text.strip() == "" and not attachment_ids:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
|
||||
# Все вложения должны принадлежать этому чату.
|
||||
if attachment_ids:
|
||||
found = storage.list_attachments_by_ids(attachment_ids, chat_id)
|
||||
if len(found) != len(attachment_ids):
|
||||
raise HTTPException(status_code=404, detail="not_found")
|
||||
for aid in attachment_ids:
|
||||
att, _key = found[aid]
|
||||
if att.status == "failed":
|
||||
raise HTTPException(status_code=409, detail="conflict")
|
||||
|
||||
method = "POST"
|
||||
path = "/api/v1/chats/%s/messages" % chat_id
|
||||
body_hash = _canonical_body_hash(payload)
|
||||
|
||||
# Атомарная операция: INSERT ключа + INSERT сообщения + UPDATE ключа
|
||||
# в ОДНОЙ транзакции. Сбой между ними невозможен: либо всё, либо ничего.
|
||||
state, message, info = storage.add_message_idempotent(
|
||||
chat_id=chat_id,
|
||||
sender_id=user.id,
|
||||
text=text,
|
||||
attachment_ids=attachment_ids,
|
||||
user_id=user.id,
|
||||
method=method,
|
||||
path=path,
|
||||
key=idempotency_key,
|
||||
body_hash=body_hash,
|
||||
)
|
||||
|
||||
if state == "created":
|
||||
return message
|
||||
|
||||
if state == "retry":
|
||||
raise HTTPException(status_code=503, detail="unavailable")
|
||||
|
||||
# state == "replay"
|
||||
if info["body_hash"] != body_hash:
|
||||
raise HTTPException(status_code=409, detail="conflict")
|
||||
if info["response_status"] == 0:
|
||||
# Строка от старой версии кода: не зависаем, отдаём 503.
|
||||
raise HTTPException(status_code=503, detail="unavailable")
|
||||
return Message.model_validate(info["response_body"])
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/{chat_id}/messages",
|
||||
summary="Получить историю сообщений чата",
|
||||
response_model=MessagePage,
|
||||
)
|
||||
def list_messages(
|
||||
chat_id: UUID,
|
||||
user: User = Depends(current_user),
|
||||
limit: int = Query(50, ge=1, le=100),
|
||||
cursor: str | None = None,
|
||||
) -> MessagePage:
|
||||
"""Keyset-пагинация в SQL: (created_at, id) по возрастанию"""
|
||||
_require_member(chat_id, user.id)
|
||||
after = _decode_cursor(chat_id, cursor) if cursor else None
|
||||
rows = storage.list_messages_page(chat_id, limit + 1, after=after)
|
||||
has_more = len(rows) > limit
|
||||
items = rows[:limit]
|
||||
next_cursor = _encode_cursor(chat_id, items[-1]) if has_more and items else None
|
||||
return MessagePage(items=items, next_cursor=next_cursor)
|
||||
@@ -0,0 +1,24 @@
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import HTTPException, Security
|
||||
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
|
||||
|
||||
from ..models.schemas import User
|
||||
from ..storage.postgres import storage
|
||||
|
||||
bearer_scheme = HTTPBearer(auto_error=False, scheme_name="bearerAuth")
|
||||
|
||||
|
||||
def current_user(
|
||||
credentials: HTTPAuthorizationCredentials | None = Security(bearer_scheme),
|
||||
) -> User:
|
||||
"""Достаёт Bearer-токен и возвращает владельца сессии.
|
||||
|
||||
Basic на бизнес-endpoint не принимается, X-User-Id игнорируется.
|
||||
"""
|
||||
if credentials is None or credentials.scheme.lower() != "bearer":
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
user = storage.get_session_user(credentials.credentials)
|
||||
if user is None:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
return user
|
||||
@@ -0,0 +1,31 @@
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from ..models.schemas import CreateUser, User
|
||||
from ..storage.postgres import storage
|
||||
from .security import current_user
|
||||
|
||||
router = APIRouter(prefix="/api/v1", tags=["users"])
|
||||
|
||||
|
||||
@router.post(
|
||||
path="/users",
|
||||
summary="Создать пользователя",
|
||||
response_model=User,
|
||||
status_code=201,
|
||||
)
|
||||
def register_user(payload: CreateUser) -> User:
|
||||
"""Публичная регистрация. Пробельные display_name/password отсекаются
|
||||
валидаторами схемы; сюда попадают только валидные значения."""
|
||||
try:
|
||||
return storage.create_user(payload.username, payload.display_name, payload.password)
|
||||
except ValueError:
|
||||
raise HTTPException(status_code=409, detail="conflict")
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/users/me",
|
||||
summary="Получить текущего пользователя",
|
||||
response_model=User,
|
||||
)
|
||||
def current_user_me(user: User = Depends(current_user)) -> User:
|
||||
"""Текущий пользователь по Bearer-сессии."""
|
||||
return user
|
||||
+192
@@ -0,0 +1,192 @@
|
||||
import logging
|
||||
import os
|
||||
import signal
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.openapi.utils import get_openapi
|
||||
from fastapi.responses import JSONResponse
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
import psycopg
|
||||
import uvicorn
|
||||
from .api import attachments, auth, chats, health, messages, users
|
||||
from .storage.db import init_pool, close_pool
|
||||
|
||||
|
||||
# --- Логирование: структурированный stdout, без содержимого сообщений ---
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s %(levelname)s %(name)s %(message)s",
|
||||
stream=sys.stdout,
|
||||
)
|
||||
logger = logging.getLogger("app")
|
||||
|
||||
# X-Instance-Id: стабильный в пределах жизни процесса. Значение приходит
|
||||
# из env INSTANCE_ID (задаётся Dockerfile/Compose) либо генерируется один раз.
|
||||
INSTANCE_ID = os.environ.get("INSTANCE_ID") or uuid.uuid4().hex[:12]
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app: FastAPI):
|
||||
init_pool() # пул соединений PostgreSQL с таймаутами
|
||||
logger.info(
|
||||
"event=startup app_env=%s session_store=%s instance_id=%s",
|
||||
os.environ.get("APP_ENV", "lab"),
|
||||
os.environ.get("SESSION_STORE", "postgres"),
|
||||
INSTANCE_ID,
|
||||
)
|
||||
yield
|
||||
close_pool()
|
||||
logger.info("event=shutdown_complete instance_id=%s", INSTANCE_ID)
|
||||
|
||||
|
||||
app = FastAPI(
|
||||
title="MTUCI Messenger — lab4",
|
||||
version="1.4.0",
|
||||
lifespan=lifespan,
|
||||
swagger_ui_parameters={"persistAuthorization": True},
|
||||
)
|
||||
|
||||
|
||||
def custom_openapi():
|
||||
if app.openapi_schema:
|
||||
return app.openapi_schema
|
||||
schema = get_openapi(title=app.title, version=app.version, routes=app.routes)
|
||||
app.openapi_schema = schema
|
||||
return schema
|
||||
|
||||
|
||||
app.openapi = custom_openapi
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def observability_middleware(request: Request, call_next):
|
||||
"""X-Request-Id и X-Instance-Id во всех ответах + структурный лог."""
|
||||
request_id = request.headers.get("X-Request-Id") or uuid.uuid4().hex
|
||||
request.state.request_id = request_id
|
||||
started = time.monotonic()
|
||||
response = await call_next(request)
|
||||
response.headers["X-Request-Id"] = request_id
|
||||
response.headers["X-Instance-Id"] = INSTANCE_ID
|
||||
duration_ms = round((time.monotonic() - started) * 1000, 2)
|
||||
path = request.url.path
|
||||
logger.info(
|
||||
"event=http method=%s path=%s status=%s duration_ms=%s request_id=%s instance_id=%s",
|
||||
request.method, path, response.status_code,
|
||||
duration_ms, request_id, INSTANCE_ID,
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
# Словарь HTTP-кодов → кодов ошибок из контракта
|
||||
_ERROR_CODES = {
|
||||
400: "invalid_request",
|
||||
401: "unauthorized",
|
||||
404: "not_found",
|
||||
409: "conflict",
|
||||
413: "payload_too_large",
|
||||
415: "unsupported_media_type",
|
||||
429: "rate_limited",
|
||||
503: "unavailable",
|
||||
500: "internal_error",
|
||||
}
|
||||
|
||||
|
||||
def _unauthorized_challenge(path: str) -> str:
|
||||
"""Basic — только для POST /api/v1/auth/sessions; остальное — Bearer."""
|
||||
if path == "/api/v1/auth/sessions":
|
||||
return 'Basic realm="messenger", charset="UTF-8"'
|
||||
return 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
def _error_response(
|
||||
status_code: int, message: str, request_id: str, path: str = ""
|
||||
) -> JSONResponse:
|
||||
code = _ERROR_CODES.get(status_code, "internal_error")
|
||||
headers = {}
|
||||
if status_code == 401:
|
||||
headers["WWW-Authenticate"] = _unauthorized_challenge(path)
|
||||
# Контракт: X-Request-Id и X-Instance-Id обязательны во ВСЕХ ответах,
|
||||
# включая 500, которые формируются в обход middleware (exception handlers
|
||||
# срабатывают ПОСЛЕ call_next). Проставляем их здесь явно.
|
||||
headers["X-Request-Id"] = request_id
|
||||
headers["X-Instance-Id"] = INSTANCE_ID
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={"error": {"code": code, "message": message, "request_id": request_id}},
|
||||
headers=headers,
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(StarletteHTTPException)
|
||||
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
message = exc.detail if isinstance(exc.detail, str) else "Ошибка"
|
||||
return _error_response(exc.status_code, message, request_id, request.url.path)
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_exception_handler(request: Request, exc: RequestValidationError):
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
return _error_response(400, "Неверный запрос", request_id, request.url.path)
|
||||
|
||||
|
||||
@app.exception_handler(psycopg.OperationalError)
|
||||
async def db_unavailable_handler(request: Request, exc: psycopg.OperationalError):
|
||||
"""PostgreSQL недоступен → 503 unavailable, без внутренних деталей."""
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
logger.error("event=db_unavailable type=%s request_id=%s",
|
||||
type(exc).__name__, request_id)
|
||||
return _error_response(503, "Зависимость недоступна", request_id, request.url.path)
|
||||
|
||||
|
||||
@app.exception_handler(RuntimeError)
|
||||
async def runtime_error_handler(request: Request, exc: RuntimeError):
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
text = str(exc)
|
||||
if "redis_unavailable" in text:
|
||||
logger.error("event=redis_unavailable request_id=%s", request_id)
|
||||
return _error_response(503, "Зависимость недоступна", request_id, request.url.path)
|
||||
if "s3_unavailable" in text:
|
||||
logger.error("event=s3_unavailable request_id=%s", request_id)
|
||||
return _error_response(503, "Зависимость недоступна", request_id, request.url.path)
|
||||
logger.error("event=runtime_error type=%s request_id=%s",
|
||||
type(exc).__name__, request_id)
|
||||
return _error_response(500, "Внутренняя ошибка", request_id, request.url.path)
|
||||
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def unhandled_exception_handler(request: Request, exc: Exception):
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
logger.error("event=unhandled_exception type=%s request_id=%s",
|
||||
type(exc).__name__, request_id)
|
||||
return _error_response(500, "Внутренняя ошибка", request_id, request.url.path)
|
||||
|
||||
|
||||
app.include_router(health.router)
|
||||
app.include_router(auth.router)
|
||||
app.include_router(users.router)
|
||||
app.include_router(chats.router)
|
||||
app.include_router(messages.router)
|
||||
app.include_router(attachments.router)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
config = uvicorn.Config(
|
||||
"app.main:app",
|
||||
host="0.0.0.0",
|
||||
port=8080,
|
||||
log_level="info"
|
||||
)
|
||||
server = uvicorn.Server(config)
|
||||
|
||||
def _handle_sigterm(signum, frame):
|
||||
"""SIGTERM: логируем и инициируем graceful shutdown uvicorn."""
|
||||
logger.info("event=sigterm_received signal=%s", signum)
|
||||
server.should_exit = True
|
||||
|
||||
signal.signal(signal.SIGTERM, _handle_sigterm)
|
||||
server.run()
|
||||
@@ -0,0 +1,163 @@
|
||||
from datetime import datetime, timezone
|
||||
from typing import List, Optional
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field, field_serializer, field_validator
|
||||
|
||||
|
||||
def _to_z(dt: datetime) -> str:
|
||||
"""RFC 3339 UTC с Z, как требует contracts/README.md."""
|
||||
if dt.tzinfo is None:
|
||||
dt = dt.replace(tzinfo=timezone.utc)
|
||||
dt = dt.astimezone(timezone.utc)
|
||||
return dt.isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
def _not_blank(value: str) -> str:
|
||||
"""Контракт: обязательные строки не состоят только из пробельных символов."""
|
||||
if value is None or value.strip() == "":
|
||||
raise ValueError("must not be blank")
|
||||
return value
|
||||
|
||||
|
||||
class Health(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
status: str
|
||||
|
||||
|
||||
class CreateUser(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
|
||||
display_name: str = Field(min_length=1, max_length=100)
|
||||
password: str = Field(min_length=12, max_length=128)
|
||||
|
||||
@field_validator("display_name")
|
||||
@classmethod
|
||||
def _display_name_not_blank(cls, v: str) -> str:
|
||||
return _not_blank(v)
|
||||
|
||||
@field_validator("password")
|
||||
@classmethod
|
||||
def _password_not_blank(cls, v: str) -> str:
|
||||
return _not_blank(v)
|
||||
|
||||
|
||||
class User(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
id: UUID
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: datetime
|
||||
|
||||
@field_serializer("created_at")
|
||||
def _ser_created_at(self, dt: datetime) -> str:
|
||||
return _to_z(dt)
|
||||
|
||||
|
||||
class CreateChat(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
title: str = Field(min_length=1, max_length=100)
|
||||
member_ids: List[UUID] = Field(min_length=1, max_length=100)
|
||||
|
||||
@field_validator("title")
|
||||
@classmethod
|
||||
def _title_not_blank(cls, v: str) -> str:
|
||||
return _not_blank(v)
|
||||
|
||||
|
||||
class Chat(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
id: UUID
|
||||
title: str
|
||||
member_ids: List[UUID]
|
||||
created_at: datetime
|
||||
|
||||
@field_serializer("created_at")
|
||||
def _ser_created_at(self, dt: datetime) -> str:
|
||||
return _to_z(dt)
|
||||
|
||||
|
||||
class CreateMessage(BaseModel):
|
||||
"""text может быть пустым, если есть хотя бы одно вложение (lab4)."""
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
text: str = Field(default="", max_length=4000)
|
||||
attachment_ids: List[UUID] = Field(default_factory=list, max_length=10)
|
||||
|
||||
@field_validator("attachment_ids")
|
||||
@classmethod
|
||||
def _unique_attachments(cls, v: List[UUID]) -> List[UUID]:
|
||||
if len(set(v)) != len(v):
|
||||
raise ValueError("duplicate attachment_ids")
|
||||
return v
|
||||
|
||||
|
||||
class Message(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
id: UUID
|
||||
chat_id: UUID
|
||||
sender_id: UUID
|
||||
text: str
|
||||
created_at: datetime
|
||||
attachment_ids: List[UUID] = Field(default_factory=list)
|
||||
|
||||
@field_serializer("created_at")
|
||||
def _ser_created_at(self, dt: datetime) -> str:
|
||||
return _to_z(dt)
|
||||
|
||||
|
||||
class ChatPage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
items: List[Chat]
|
||||
next_cursor: Optional[str] = None
|
||||
|
||||
|
||||
class MessagePage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
items: List[Message]
|
||||
next_cursor: Optional[str] = None
|
||||
|
||||
|
||||
class Session(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
token: str
|
||||
token_type: str = "Bearer"
|
||||
expires_at: datetime
|
||||
user: User
|
||||
|
||||
@field_serializer("expires_at")
|
||||
def _ser_expires_at(self, dt: datetime) -> str:
|
||||
return _to_z(dt)
|
||||
|
||||
|
||||
class Variant(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
name: str
|
||||
content_type: str
|
||||
size_bytes: int
|
||||
width: int
|
||||
height: int
|
||||
sha256: str
|
||||
|
||||
|
||||
class Attachment(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
id: UUID
|
||||
chat_id: UUID
|
||||
owner_id: UUID
|
||||
filename: str
|
||||
content_type: str
|
||||
size_bytes: int
|
||||
sha256: str
|
||||
status: str # "ready"
|
||||
variants: List[Variant] = Field(default_factory=list)
|
||||
error_code: Optional[str] = None
|
||||
created_at: datetime
|
||||
updated_at: datetime
|
||||
|
||||
@field_serializer("created_at")
|
||||
def _ser_created_at(self, dt: datetime) -> str:
|
||||
return _to_z(dt)
|
||||
|
||||
@field_serializer("updated_at")
|
||||
def _ser_updated_at(self, dt: datetime) -> str:
|
||||
return _to_z(dt)
|
||||
@@ -0,0 +1,176 @@
|
||||
import os
|
||||
from contextlib import contextmanager
|
||||
from typing import Iterator
|
||||
|
||||
import psycopg
|
||||
from psycopg_pool import ConnectionPool
|
||||
|
||||
|
||||
_pool: ConnectionPool | None = None
|
||||
|
||||
|
||||
def _dsn() -> str:
|
||||
dsn = os.environ.get("DATABASE_URL")
|
||||
if not dsn:
|
||||
raise RuntimeError("DATABASE_URL is not set")
|
||||
return dsn
|
||||
|
||||
|
||||
def init_pool() -> None:
|
||||
"""Ограниченный пул соединений с таймаутами. Вызывается один раз на старте."""
|
||||
global _pool
|
||||
if _pool is not None:
|
||||
return
|
||||
_pool = ConnectionPool(
|
||||
conninfo=_dsn(),
|
||||
min_size=2,
|
||||
max_size=10,
|
||||
timeout=5.0,
|
||||
max_idle=300.0,
|
||||
kwargs={"options": "-c statement_timeout=5000"},
|
||||
open=True,
|
||||
)
|
||||
|
||||
|
||||
def close_pool() -> None:
|
||||
global _pool
|
||||
if _pool is not None:
|
||||
_pool.close()
|
||||
_pool = None
|
||||
|
||||
|
||||
@contextmanager
|
||||
def connection() -> Iterator[psycopg.Connection]:
|
||||
"""Соединение из пула; autocommit=False для явных транзакций."""
|
||||
if _pool is None:
|
||||
init_pool()
|
||||
assert _pool is not None
|
||||
with _pool.connection() as conn:
|
||||
yield conn
|
||||
|
||||
|
||||
SCHEMA_SQL = """
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id UUID PRIMARY KEY,
|
||||
username TEXT NOT NULL UNIQUE,
|
||||
display_name TEXT NOT NULL,
|
||||
password_hash TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chats (
|
||||
id UUID PRIMARY KEY,
|
||||
title TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chat_members (
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS messages (
|
||||
id UUID PRIMARY KEY,
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
text TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_messages_chat_created
|
||||
ON messages (chat_id, created_at, id);
|
||||
|
||||
-- sessions остаются как fallback, если SESSION_STORE=postgres.
|
||||
CREATE TABLE IF NOT EXISTS sessions (
|
||||
token TEXT PRIMARY KEY,
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
expires_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
-- lab3: общая идемпотентность POST /messages.
|
||||
-- scope: user_id + method + path + key (см. contracts/README.md).
|
||||
-- body_hash — sha256 канонизированного JSON без attachment_ids=[], чтобы
|
||||
-- отличать повтор «того же» body (201, тот же Message) от «другого» (409).
|
||||
CREATE TABLE IF NOT EXISTS idempotency_keys (
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
method TEXT NOT NULL,
|
||||
path TEXT NOT NULL,
|
||||
key TEXT NOT NULL,
|
||||
body_hash TEXT NOT NULL,
|
||||
response_status INT NOT NULL,
|
||||
response_body JSONB NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (user_id, method, path, key)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_idempotency_created
|
||||
ON idempotency_keys (created_at);
|
||||
|
||||
-- lab4: вложения
|
||||
CREATE TABLE IF NOT EXISTS attachments (
|
||||
id UUID PRIMARY KEY,
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
owner_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
filename TEXT NOT NULL,
|
||||
content_type TEXT NOT NULL,
|
||||
size_bytes BIGINT NOT NULL,
|
||||
sha256 TEXT NOT NULL,
|
||||
object_key TEXT NOT NULL UNIQUE,
|
||||
status TEXT NOT NULL, -- ready (lab4), queued/processing/failed (lab5)
|
||||
error_code TEXT,
|
||||
created_at TIMESTAMPTZ NOT NULL,
|
||||
updated_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_attachments_chat
|
||||
ON attachments (chat_id);
|
||||
|
||||
-- связь сообщение↔вложение (порядок сохраняем)
|
||||
CREATE TABLE IF NOT EXISTS message_attachments (
|
||||
message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
|
||||
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE,
|
||||
position INT NOT NULL,
|
||||
PRIMARY KEY (message_id, attachment_id)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_msg_att_message
|
||||
ON message_attachments (message_id, position);
|
||||
"""
|
||||
|
||||
|
||||
def init_schema() -> None:
|
||||
"""Идемпотентная миграция: безопасно вызывать многократно.
|
||||
|
||||
Вызывается ОДИН РАЗ отдельным one-shot сервисом migrate
|
||||
(см. compose.yaml). Реплики API миграции больше не выполняют:
|
||||
они ждут service_completed_successfully.
|
||||
"""
|
||||
with connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(SCHEMA_SQL)
|
||||
conn.commit()
|
||||
|
||||
|
||||
def run_migrations() -> None:
|
||||
"""Точка входа для one-shot migrate-контейнера.
|
||||
|
||||
Поднимает пул, применяет схему, закрывает пул. Завершается с кодом 0
|
||||
при успехе — этого достаточно для service_completed_successfully.
|
||||
"""
|
||||
init_pool()
|
||||
try:
|
||||
init_schema()
|
||||
finally:
|
||||
close_pool()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Запуск: python -m app.storage.db
|
||||
# (в compose.yaml — command: ["python", "-m", "app.storage.db"])
|
||||
import logging
|
||||
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s %(levelname)s %(name)s %(message)s",
|
||||
)
|
||||
log = logging.getLogger("migrate")
|
||||
log.info("event=migrations_start")
|
||||
run_migrations()
|
||||
log.info("event=migrations_done")
|
||||
@@ -0,0 +1,177 @@
|
||||
import hashlib
|
||||
import hmac
|
||||
import secrets
|
||||
import threading
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import Dict, List, Optional
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from ..models.schemas import Chat, Message, User
|
||||
|
||||
|
||||
def now_utc() -> datetime:
|
||||
"""Время сервера в UTC с суффиксом Z на выходе."""
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
# --- Password KDF (stdlib scrypt) ---
|
||||
_SCRYPT_N = 2 ** 14
|
||||
_SCRYPT_R = 8
|
||||
_SCRYPT_P = 1
|
||||
_SCRYPT_DKLEN = 32
|
||||
|
||||
|
||||
def _hash_password(password: str) -> str:
|
||||
salt = secrets.token_bytes(16)
|
||||
dk = hashlib.scrypt(
|
||||
password.encode("utf-8"),
|
||||
salt=salt,
|
||||
n=_SCRYPT_N,
|
||||
r=_SCRYPT_R,
|
||||
p=_SCRYPT_P,
|
||||
dklen=_SCRYPT_DKLEN,
|
||||
)
|
||||
return "scrypt$%d$%d$%d$%s$%s" % (
|
||||
_SCRYPT_N, _SCRYPT_R, _SCRYPT_P,
|
||||
salt.hex(), dk.hex(),
|
||||
)
|
||||
|
||||
|
||||
def _verify_password(password: str, stored: str) -> bool:
|
||||
try:
|
||||
scheme, n, r, p, salt_hex, dk_hex = stored.split("$")
|
||||
if scheme != "scrypt":
|
||||
return False
|
||||
dk = hashlib.scrypt(
|
||||
password.encode("utf-8"),
|
||||
salt=bytes.fromhex(salt_hex),
|
||||
n=int(n), r=int(r), p=int(p),
|
||||
dklen=len(bytes.fromhex(dk_hex)),
|
||||
)
|
||||
return hmac.compare_digest(dk.hex(), dk_hex)
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
class MemoryStorage:
|
||||
"""Потокобезопасное In-memory хранилище пользователей, чатов, сообщений и сессий. Все данные исчезают при перезапуске процесса"""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._lock = threading.RLock()
|
||||
self._users: Dict[UUID, User] = {}
|
||||
self._usernames: Dict[str, UUID] = {}
|
||||
self._passwords: Dict[UUID, str] = {}
|
||||
self._chats: Dict[UUID, Chat] = {}
|
||||
self._messages: Dict[UUID, List[Message]] = {}
|
||||
# token -> (user_id, expires_at)
|
||||
self._sessions: Dict[str, tuple] = {}
|
||||
|
||||
# ---------- Пользователи ----------
|
||||
def create_user(self, username: str, display_name: str, password: str) -> User:
|
||||
with self._lock:
|
||||
if username in self._usernames:
|
||||
raise ValueError("username_taken")
|
||||
user = User(
|
||||
id=uuid4(),
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
created_at=now_utc(),
|
||||
)
|
||||
self._users[user.id] = user
|
||||
self._usernames[username] = user.id
|
||||
self._passwords[user.id] = _hash_password(password)
|
||||
return user
|
||||
|
||||
def get_user(self, user_id: UUID) -> Optional[User]:
|
||||
with self._lock:
|
||||
return self._users.get(user_id)
|
||||
|
||||
def get_user_by_username(self, username: str) -> Optional[User]:
|
||||
with self._lock:
|
||||
uid = self._usernames.get(username)
|
||||
return self._users.get(uid) if uid else None
|
||||
|
||||
def verify_credentials(self, username: str, password: str) -> Optional[User]:
|
||||
with self._lock:
|
||||
uid = self._usernames.get(username)
|
||||
if uid is None:
|
||||
return None
|
||||
stored = self._passwords.get(uid)
|
||||
if not stored or not _verify_password(password, stored):
|
||||
return None
|
||||
return self._users.get(uid)
|
||||
|
||||
# ---------- Сессии ----------
|
||||
def create_session(self, user_id: UUID, ttl_seconds: int) -> tuple:
|
||||
with self._lock:
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires_at = now_utc() + timedelta(seconds=ttl_seconds)
|
||||
self._sessions[token] = (user_id, expires_at)
|
||||
return token, expires_at
|
||||
|
||||
def get_session_user(self, token: str) -> Optional[User]:
|
||||
with self._lock:
|
||||
entry = self._sessions.get(token)
|
||||
if entry is None:
|
||||
return None
|
||||
user_id, expires_at = entry
|
||||
if expires_at <= now_utc():
|
||||
self._sessions.pop(token, None)
|
||||
return None
|
||||
return self._users.get(user_id)
|
||||
|
||||
def revoke_session(self, token: str) -> None:
|
||||
with self._lock:
|
||||
self._sessions.pop(token, None)
|
||||
|
||||
# ---------- Чаты ----------
|
||||
def create_chat(self, title: str, member_ids: List[UUID]) -> Chat:
|
||||
with self._lock:
|
||||
for uid in member_ids:
|
||||
if uid not in self._users:
|
||||
raise ValueError("unknown_member")
|
||||
chat = Chat(
|
||||
id=uuid4(),
|
||||
title=title,
|
||||
member_ids=list(member_ids),
|
||||
created_at=now_utc(),
|
||||
)
|
||||
self._chats[chat.id] = chat
|
||||
self._messages[chat.id] = []
|
||||
return chat
|
||||
|
||||
def get_chat(self, chat_id: UUID) -> Optional[Chat]:
|
||||
with self._lock:
|
||||
return self._chats.get(chat_id)
|
||||
|
||||
def list_chats_for_user(self, user_id: UUID) -> List[Chat]:
|
||||
with self._lock:
|
||||
chats = [c for c in self._chats.values() if user_id in c.member_ids]
|
||||
chats.sort(key=lambda c: (c.created_at, str(c.id)))
|
||||
return chats
|
||||
|
||||
# ---------- Сообщения ----------
|
||||
def add_message(self, chat_id: UUID, sender_id: UUID, text: str) -> Message:
|
||||
"""Улучшение Трека 1: список сообщений хранится уже отсортированным.
|
||||
created_at монотонен в пределах одного процесса, поэтому append
|
||||
сохраняет порядок (created_at, id) по возрастанию — сортировка на
|
||||
чтении не нужна. При конкурентных вставках под RLock порядок
|
||||
сохраняется, но монотонность часов не гарантируется контрактом."""
|
||||
with self._lock:
|
||||
message = Message(
|
||||
id=uuid4(),
|
||||
chat_id=chat_id,
|
||||
sender_id=sender_id,
|
||||
text=text,
|
||||
created_at=now_utc(),
|
||||
)
|
||||
self._messages.setdefault(chat_id, []).append(message)
|
||||
return message
|
||||
|
||||
def list_messages(self, chat_id: UUID) -> List[Message]:
|
||||
with self._lock:
|
||||
# Без пересортировки: список уже в порядке (created_at, id).
|
||||
return list(self._messages.get(chat_id, []))
|
||||
|
||||
|
||||
storage = MemoryStorage() # единственный экземпляр хранилища на процесс
|
||||
@@ -0,0 +1,458 @@
|
||||
import hashlib
|
||||
import hmac
|
||||
import secrets
|
||||
import threading
|
||||
from datetime import datetime, timezone
|
||||
from typing import List, Optional
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from ..models.schemas import Attachment, Chat, Message, User, Variant
|
||||
from .db import connection
|
||||
from .sessions import (
|
||||
create_session as _sess_create,
|
||||
get_session_user as _sess_get,
|
||||
revoke_session as _sess_revoke,
|
||||
)
|
||||
|
||||
|
||||
def now_utc() -> datetime:
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
# --- Password KDF (stdlib scrypt) ---
|
||||
_SCRYPT_N = 2 ** 14
|
||||
_SCRYPT_R = 8
|
||||
_SCRYPT_P = 1
|
||||
_SCRYPT_DKLEN = 32
|
||||
|
||||
|
||||
def _hash_password(password: str) -> str:
|
||||
salt = secrets.token_bytes(16)
|
||||
dk = hashlib.scrypt(
|
||||
password.encode("utf-8"),
|
||||
salt=salt,
|
||||
n=_SCRYPT_N, r=_SCRYPT_R, p=_SCRYPT_P, dklen=_SCRYPT_DKLEN,
|
||||
)
|
||||
return "scrypt$%d$%d$%d$%s$%s" % (
|
||||
_SCRYPT_N, _SCRYPT_R, _SCRYPT_P, salt.hex(), dk.hex(),
|
||||
)
|
||||
|
||||
|
||||
def _verify_password(password: str, stored: str) -> bool:
|
||||
try:
|
||||
scheme, n, r, p, salt_hex, dk_hex = stored.split("$")
|
||||
if scheme != "scrypt":
|
||||
return False
|
||||
dk = hashlib.scrypt(
|
||||
password.encode("utf-8"),
|
||||
salt=bytes.fromhex(salt_hex),
|
||||
n=int(n), r=int(r), p=int(p),
|
||||
dklen=len(bytes.fromhex(dk_hex)),
|
||||
)
|
||||
return hmac.compare_digest(dk.hex(), dk_hex)
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def _row_to_user(row) -> User:
|
||||
return User(id=row[0], username=row[1], display_name=row[2], created_at=row[3])
|
||||
|
||||
|
||||
def _row_to_chat(row, member_ids: List[UUID]) -> Chat:
|
||||
return Chat(id=row[0], title=row[1], member_ids=member_ids, created_at=row[2])
|
||||
|
||||
|
||||
def _row_to_message(row, attachment_ids: List[UUID]) -> Message:
|
||||
return Message(
|
||||
id=row[0], chat_id=row[1], sender_id=row[2],
|
||||
text=row[3], created_at=row[4],
|
||||
attachment_ids=attachment_ids,
|
||||
)
|
||||
|
||||
|
||||
def _row_to_attachment(row) -> Attachment:
|
||||
# row: id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
|
||||
# status, error_code, created_at, updated_at
|
||||
return Attachment(
|
||||
id=row[0], chat_id=row[1], owner_id=row[2],
|
||||
filename=row[3], content_type=row[4], size_bytes=row[5],
|
||||
sha256=row[6], status=row[7], variants=[], error_code=row[8],
|
||||
created_at=row[9], updated_at=row[10],
|
||||
)
|
||||
|
||||
|
||||
class PostgresStorage:
|
||||
"""Потокобезопасная обёртка; параллелизм обеспечивает PostgreSQL."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._lock = threading.RLock()
|
||||
|
||||
# ---------- Пользователи ----------
|
||||
def create_user(self, username: str, display_name: str, password: str) -> User:
|
||||
with self._lock, connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
# SELECT-проверка + INSERT в одной транзакции; уникальный индекс
|
||||
# users.username отсекает гонку на уровне БД (UniqueViolation).
|
||||
cur.execute("SELECT 1 FROM users WHERE username = %s", (username,))
|
||||
if cur.fetchone() is not None:
|
||||
raise ValueError("username_taken")
|
||||
user = User(
|
||||
id=uuid4(), username=username,
|
||||
display_name=display_name, created_at=now_utc(),
|
||||
)
|
||||
try:
|
||||
cur.execute(
|
||||
"INSERT INTO users (id, username, display_name, password_hash, created_at)"
|
||||
" VALUES (%s, %s, %s, %s, %s)",
|
||||
(user.id, user.username, user.display_name,
|
||||
_hash_password(password), user.created_at),
|
||||
)
|
||||
except Exception as exc:
|
||||
# Параллельная регистрация того же username: уникальный индекс
|
||||
# выбросил UniqueViolation — превращаем в доменную ошибку.
|
||||
if exc.__class__.__name__ == "UniqueViolation":
|
||||
raise ValueError("username_taken")
|
||||
raise
|
||||
conn.commit()
|
||||
return user
|
||||
|
||||
def get_user(self, user_id: UUID) -> Optional[User]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
|
||||
(user_id,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
return _row_to_user(row) if row else None
|
||||
|
||||
def get_user_by_username(self, username: str) -> Optional[User]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, username, display_name, created_at FROM users WHERE username = %s",
|
||||
(username,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
return _row_to_user(row) if row else None
|
||||
|
||||
def verify_credentials(self, username: str, password: str) -> Optional[User]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, username, display_name, created_at, password_hash"
|
||||
" FROM users WHERE username = %s",
|
||||
(username,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
if not _verify_password(password, row[4]):
|
||||
return None
|
||||
return _row_to_user(row[:4])
|
||||
|
||||
# ---------- Сессии (Redis или PostgreSQL — см. storage/sessions.py) ----------
|
||||
# Тонкие делегаты: роутеры продолжают вызывать storage.create_session(...),
|
||||
# storage.get_session_user(...), storage.revoke_session(...) без изменений.
|
||||
def create_session(self, user_id: UUID, ttl_seconds: int) -> tuple:
|
||||
return _sess_create(user_id, ttl_seconds)
|
||||
|
||||
def get_session_user(self, token: str) -> Optional[User]:
|
||||
return _sess_get(token)
|
||||
|
||||
def revoke_session(self, token: str) -> None:
|
||||
_sess_revoke(token)
|
||||
|
||||
# ---------- Чаты ----------
|
||||
def create_chat(self, title: str, member_ids: List[UUID]) -> Chat:
|
||||
with self._lock, connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
# проверяем всех участников
|
||||
cur.execute(
|
||||
"SELECT id FROM users WHERE id = ANY(%s)",
|
||||
(list(member_ids),),
|
||||
)
|
||||
found = {r[0] for r in cur.fetchall()}
|
||||
if len(found) != len(set(member_ids)):
|
||||
raise ValueError("unknown_member")
|
||||
chat = Chat(
|
||||
id=uuid4(), title=title,
|
||||
member_ids=list(member_ids), created_at=now_utc(),
|
||||
)
|
||||
cur.execute(
|
||||
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)",
|
||||
(chat.id, chat.title, chat.created_at),
|
||||
)
|
||||
cur.executemany(
|
||||
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
|
||||
[(chat.id, uid) for uid in member_ids],
|
||||
)
|
||||
conn.commit()
|
||||
return chat
|
||||
|
||||
def get_chat(self, chat_id: UUID) -> Optional[Chat]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, title, created_at FROM chats WHERE id = %s",
|
||||
(chat_id,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
cur.execute(
|
||||
"SELECT user_id FROM chat_members WHERE chat_id = %s", (chat_id,),
|
||||
)
|
||||
members = [r[0] for r in cur.fetchall()]
|
||||
return _row_to_chat(row, members)
|
||||
|
||||
def list_chats_for_user(self, user_id: UUID) -> List[Chat]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT c.id, c.title, c.created_at FROM chats c"
|
||||
" JOIN chat_members m ON m.chat_id = c.id"
|
||||
" WHERE m.user_id = %s ORDER BY c.created_at, c.id",
|
||||
(user_id,),
|
||||
)
|
||||
rows = cur.fetchall()
|
||||
chats = []
|
||||
for row in rows:
|
||||
cur.execute(
|
||||
"SELECT user_id FROM chat_members WHERE chat_id = %s", (row[0],),
|
||||
)
|
||||
members = [r[0] for r in cur.fetchall()]
|
||||
chats.append(_row_to_chat(row, members))
|
||||
return chats
|
||||
|
||||
# ---------- Сообщения ----------
|
||||
def _load_message_attachments(
|
||||
self, cur, message_ids: List[UUID]
|
||||
) -> dict[UUID, List[UUID]]:
|
||||
"""Одним запросом достаём attachment_ids для набора сообщений."""
|
||||
if not message_ids:
|
||||
return {}
|
||||
cur.execute(
|
||||
"SELECT message_id, attachment_id, position FROM message_attachments"
|
||||
" WHERE message_id = ANY(%s) ORDER BY message_id, position",
|
||||
(list(message_ids),),
|
||||
)
|
||||
result: dict[UUID, List[UUID]] = {}
|
||||
for mid, aid, _pos in cur.fetchall():
|
||||
result.setdefault(mid, []).append(aid)
|
||||
return result
|
||||
|
||||
def list_messages_page(
|
||||
self,
|
||||
chat_id: UUID,
|
||||
limit: int,
|
||||
after: Optional[tuple] = None,
|
||||
) -> List[Message]:
|
||||
"""Keyset-пагинация в SQL
|
||||
|
||||
after = (created_at, id) последней записи предыдущей страницы или None.
|
||||
Запрос использует индекс idx_messages_chat_created (chat_id, created_at, id)
|
||||
и не делает полный scan всей истории на каждую страницу.
|
||||
"""
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
if after is None:
|
||||
cur.execute(
|
||||
"SELECT id, chat_id, sender_id, text, created_at FROM messages"
|
||||
" WHERE chat_id = %s ORDER BY created_at, id LIMIT %s",
|
||||
(chat_id, limit),
|
||||
)
|
||||
else:
|
||||
after_ts, after_id = after
|
||||
cur.execute(
|
||||
"SELECT id, chat_id, sender_id, text, created_at FROM messages"
|
||||
" WHERE chat_id = %s AND (created_at, id) > (%s, %s)"
|
||||
" ORDER BY created_at, id LIMIT %s",
|
||||
(chat_id, after_ts, after_id, limit),
|
||||
)
|
||||
rows = cur.fetchall()
|
||||
ids = [r[0] for r in rows]
|
||||
att_map = self._load_message_attachments(cur, ids)
|
||||
return [_row_to_message(r, att_map.get(r[0], [])) for r in rows]
|
||||
|
||||
# ---------- Идемпотентность (lab3) ----------
|
||||
def add_message_idempotent(
|
||||
self,
|
||||
chat_id: UUID,
|
||||
sender_id: UUID,
|
||||
text: str,
|
||||
attachment_ids: List[UUID],
|
||||
user_id: UUID,
|
||||
method: str,
|
||||
path: str,
|
||||
key: str,
|
||||
body_hash: str,
|
||||
) -> tuple[str, Optional[Message], Optional[dict]]:
|
||||
"""Атомарная отправка сообщения с идемпотентностью.
|
||||
|
||||
Возвращает одно из:
|
||||
('created', message, None) — мы выиграли гонку и создали сообщение;
|
||||
('replay', None, info) — ключ уже занят; info = {body_hash,
|
||||
response_status, response_body}
|
||||
('retry', None, None) — конфликт при INSERT, но строки нет
|
||||
(крайне редко); вызывающий может
|
||||
повторить запрос.
|
||||
|
||||
ВСЁ делается в ОДНОЙ транзакции: либо строка idempotency_keys
|
||||
и строка messages фиксируются вместе, либо не фиксируется ничего.
|
||||
Это устраняет блокер, когда сообщение сохранено, а ключ остался
|
||||
с response_status=0 и повтор зависал.
|
||||
"""
|
||||
import json as _json
|
||||
with connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
# 1) Пытаемся занять ключ. ON CONFLICT DO NOTHING — атомарно.
|
||||
cur.execute(
|
||||
"INSERT INTO idempotency_keys"
|
||||
" (user_id, method, path, key, body_hash, response_status, response_body)"
|
||||
" VALUES (%s, %s, %s, %s, %s, 0, '{}'::jsonb)"
|
||||
" ON CONFLICT (user_id, method, path, key) DO NOTHING"
|
||||
" RETURNING key",
|
||||
(user_id, method, path, key, body_hash),
|
||||
)
|
||||
won = cur.fetchone() is not None
|
||||
|
||||
if won:
|
||||
# 2) Мы выиграли: создаём сообщение в ТОЙ ЖЕ транзакции.
|
||||
message = Message(
|
||||
id=uuid4(), chat_id=chat_id, sender_id=sender_id,
|
||||
text=text, created_at=now_utc(),
|
||||
attachment_ids=list(attachment_ids),
|
||||
)
|
||||
cur.execute(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text, created_at)"
|
||||
" VALUES (%s, %s, %s, %s, %s)",
|
||||
(message.id, message.chat_id, message.sender_id,
|
||||
message.text, message.created_at),
|
||||
)
|
||||
if attachment_ids:
|
||||
cur.executemany(
|
||||
"INSERT INTO message_attachments"
|
||||
" (message_id, attachment_id, position)"
|
||||
" VALUES (%s, %s, %s)",
|
||||
[(message.id, aid, idx)
|
||||
for idx, aid in enumerate(attachment_ids)],
|
||||
)
|
||||
# 3) Пишем финальный ответ в ту же строку ключа.
|
||||
body_json = _json.loads(message.model_dump_json())
|
||||
cur.execute(
|
||||
"UPDATE idempotency_keys"
|
||||
" SET response_status = %s, response_body = %s"
|
||||
" WHERE user_id = %s AND method = %s AND path = %s AND key = %s",
|
||||
(201, _json.dumps(body_json),
|
||||
user_id, method, path, key),
|
||||
)
|
||||
# Один commit — либо всё, либо ничего.
|
||||
conn.commit()
|
||||
return ("created", message, None)
|
||||
|
||||
# Ключ уже занят. Читаем строку в этой же транзакции.
|
||||
cur.execute(
|
||||
"SELECT body_hash, response_status, response_body"
|
||||
" FROM idempotency_keys"
|
||||
" WHERE user_id = %s AND method = %s AND path = %s AND key = %s",
|
||||
(user_id, method, path, key),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
conn.commit()
|
||||
|
||||
if row is None:
|
||||
# Только что был конфликт, а строки нет — редкий случай; повтор.
|
||||
return ("retry", None, None)
|
||||
return (
|
||||
"replay",
|
||||
None,
|
||||
{
|
||||
"body_hash": row[0],
|
||||
"response_status": row[1],
|
||||
"response_body": row[2],
|
||||
},
|
||||
)
|
||||
|
||||
# ---------- Вложения ----------
|
||||
def create_attachment(
|
||||
self,
|
||||
attachment: Attachment,
|
||||
object_key: str,
|
||||
) -> Attachment:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"INSERT INTO attachments"
|
||||
" (id, chat_id, owner_id, filename, content_type, size_bytes,"
|
||||
" sha256, object_key, status, error_code, created_at, updated_at)"
|
||||
" VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)",
|
||||
(
|
||||
attachment.id, attachment.chat_id, attachment.owner_id,
|
||||
attachment.filename, attachment.content_type,
|
||||
attachment.size_bytes, attachment.sha256, object_key,
|
||||
attachment.status, attachment.error_code,
|
||||
attachment.created_at, attachment.updated_at,
|
||||
),
|
||||
)
|
||||
conn.commit()
|
||||
return attachment
|
||||
|
||||
def get_attachment(self, attachment_id: UUID) -> Optional[Attachment]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, chat_id, owner_id, filename, content_type, size_bytes,"
|
||||
" sha256, status, error_code, created_at, updated_at"
|
||||
" FROM attachments WHERE id = %s",
|
||||
(attachment_id,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
cur.execute(
|
||||
"SELECT object_key FROM attachments WHERE id = %s", (attachment_id,),
|
||||
)
|
||||
obj_row = cur.fetchone()
|
||||
att = _row_to_attachment(row)
|
||||
att_variants: List[Variant] = [] # lab4: вариантов нет
|
||||
att.variants = att_variants
|
||||
# object_key нужен вызывающему для чтения из S3; отдаём через
|
||||
# отдельный метод get_attachment_with_key.
|
||||
return att
|
||||
|
||||
def get_attachment_with_key(
|
||||
self, attachment_id: UUID
|
||||
) -> Optional[tuple[Attachment, str]]:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, chat_id, owner_id, filename, content_type, size_bytes,"
|
||||
" sha256, status, error_code, created_at, updated_at, object_key"
|
||||
" FROM attachments WHERE id = %s",
|
||||
(attachment_id,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
att = _row_to_attachment(row[:11])
|
||||
return att, row[11]
|
||||
|
||||
def list_attachments_by_ids(
|
||||
self, ids: List[UUID], chat_id: UUID
|
||||
) -> dict[UUID, tuple[Attachment, str]]:
|
||||
"""Достаём вложения этого чата. Возвращает {id: (Attachment, object_key)}."""
|
||||
if not ids:
|
||||
return {}
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, chat_id, owner_id, filename, content_type, size_bytes,"
|
||||
" sha256, status, error_code, created_at, updated_at, object_key"
|
||||
" FROM attachments WHERE chat_id = %s AND id = ANY(%s)",
|
||||
(chat_id, list(ids)),
|
||||
)
|
||||
result: dict[UUID, tuple[Attachment, str]] = {}
|
||||
for row in cur.fetchall():
|
||||
att = _row_to_attachment(row[:11])
|
||||
att.variants = []
|
||||
result[row[0]] = (att, row[11])
|
||||
return result
|
||||
|
||||
def delete_attachment(self, attachment_id: UUID) -> None:
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute("DELETE FROM attachments WHERE id = %s", (attachment_id,))
|
||||
conn.commit()
|
||||
|
||||
|
||||
storage = PostgresStorage() # единственный экземпляр на процесс
|
||||
@@ -0,0 +1,86 @@
|
||||
"""S3-клиент (MinIO) для lab4.
|
||||
|
||||
Object key генерирует сервер: attachments/<chat_id>/<attachment_id>/original.
|
||||
filename используется только для отображения, не в ключе.
|
||||
"""
|
||||
import os
|
||||
from typing import Optional
|
||||
from uuid import UUID
|
||||
|
||||
import boto3
|
||||
from botocore.client import Config
|
||||
from botocore.exceptions import ClientError
|
||||
|
||||
|
||||
def _endpoint() -> str:
|
||||
return os.environ["S3_ENDPOINT"]
|
||||
|
||||
|
||||
def _bucket() -> str:
|
||||
return os.environ.get("S3_BUCKET", "messenger-attachments")
|
||||
|
||||
|
||||
def client():
|
||||
"""Клиент с прикладными credentials (не admin).
|
||||
|
||||
Явные короткие таймауты: connect/read — чтобы при недоступности S3
|
||||
запросы падали быстро и LB отдавал 503, а не 504 по своему timeout.
|
||||
"""
|
||||
return boto3.client(
|
||||
"s3",
|
||||
endpoint_url=_endpoint(),
|
||||
region_name=os.environ.get("S3_REGION", "us-east-1"),
|
||||
aws_access_key_id=os.environ["S3_APP_KEY_ID"],
|
||||
aws_secret_access_key=os.environ["S3_APP_SECRET_KEY"],
|
||||
config=Config(
|
||||
signature_version="s3v4",
|
||||
s3={"addressing_style": "path"},
|
||||
connect_timeout=2,
|
||||
read_timeout=3,
|
||||
retries={"max_attempts": 0},
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def original_key(chat_id: UUID, attachment_id: UUID) -> str:
|
||||
"""Единственный ключ оригинала. Не зависит от filename."""
|
||||
return "attachments/%s/%s/original" % (chat_id, attachment_id)
|
||||
|
||||
|
||||
def put_bytes(key: str, data: bytes, content_type: str) -> None:
|
||||
client().put_object(
|
||||
Bucket=_bucket(),
|
||||
Key=key,
|
||||
Body=data,
|
||||
ContentType=content_type,
|
||||
ContentLength=len(data),
|
||||
)
|
||||
|
||||
|
||||
def get_object(key: str):
|
||||
"""Возвращает (bytes, content_type). Бросает ClientError при отсутствии."""
|
||||
resp = client().get_object(Bucket=_bucket(), Key=key)
|
||||
body = resp["Body"].read()
|
||||
ctype = resp.get("ContentType") or "application/octet-stream"
|
||||
return body, ctype
|
||||
|
||||
|
||||
def delete_object(key: str) -> None:
|
||||
client().delete_object(Bucket=_bucket(), Key=key)
|
||||
|
||||
|
||||
def head_object(key: str) -> Optional[dict]:
|
||||
try:
|
||||
return client().head_object(Bucket=_bucket(), Key=key)
|
||||
except ClientError as exc:
|
||||
if exc.response.get("Error", {}).get("Code") in ("404", "NoSuchKey", "NotFound"):
|
||||
return None
|
||||
raise
|
||||
|
||||
|
||||
def list_objects(prefix: str = "attachments/"):
|
||||
"""Итератор по объектам bucket. Используется cleanup-сервисом."""
|
||||
paginator = client().get_paginator("list_objects_v2")
|
||||
for page in paginator.paginate(Bucket=_bucket(), Prefix=prefix):
|
||||
for obj in page.get("Contents", []):
|
||||
yield obj
|
||||
@@ -0,0 +1,119 @@
|
||||
"""Фоновая сверка S3 и PostgreSQL (уровень 4).
|
||||
|
||||
- Orphan: объект в S3 есть, а метаданных в attachments нет.
|
||||
Удаляем только если объект старше ORPHAN_GRACE_SECONDS.
|
||||
- Missing: метаданные есть, объекта в S3 нет.
|
||||
Пишем warning в лог (не удаляем метаданные — учебная политика).
|
||||
- Object key кодирует chat_id и attachment_id, поэтому сверка по метаданным
|
||||
attachments.
|
||||
- Каждый цикл независим; падение логируется и не роняет процесс.
|
||||
"""
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from uuid import UUID
|
||||
|
||||
from . import s3
|
||||
from .db import connection, init_pool, close_pool
|
||||
|
||||
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s %(levelname)s %(name)s %(message)s",
|
||||
stream=sys.stdout,
|
||||
)
|
||||
log = logging.getLogger("s3_cleanup")
|
||||
|
||||
|
||||
def _interval() -> int:
|
||||
try:
|
||||
return max(30, int(os.environ.get("CLEANUP_INTERVAL_SECONDS", "300")))
|
||||
except ValueError:
|
||||
return 300
|
||||
|
||||
|
||||
def _grace() -> int:
|
||||
try:
|
||||
return max(0, int(os.environ.get("ORPHAN_GRACE_SECONDS", "3600")))
|
||||
except ValueError:
|
||||
return 3600
|
||||
|
||||
|
||||
def _known_keys() -> set[str]:
|
||||
"""Все ожидаемые object key из таблицы attachments."""
|
||||
keys: set[str] = set()
|
||||
with connection() as conn, conn.cursor() as cur:
|
||||
cur.execute("SELECT id, chat_id FROM attachments")
|
||||
for aid, cid in cur.fetchall():
|
||||
keys.add(s3.original_key(cid, aid))
|
||||
return keys
|
||||
|
||||
|
||||
def _run_once() -> dict:
|
||||
now = datetime.now(timezone.utc)
|
||||
grace_cutoff = now - timedelta(seconds=_grace())
|
||||
|
||||
known = _known_keys()
|
||||
orphan_deleted = 0
|
||||
missing = 0
|
||||
scanned = 0
|
||||
|
||||
for obj in s3.list_objects("attachments/"):
|
||||
scanned += 1
|
||||
key = obj["Key"]
|
||||
if key in known:
|
||||
continue
|
||||
# Orphan: в S3 есть, в БД нет. Удаляем только старше grace period.
|
||||
lm = obj.get("LastModified")
|
||||
if lm is None:
|
||||
continue
|
||||
if lm.tzinfo is None:
|
||||
lm = lm.replace(tzinfo=timezone.utc)
|
||||
if lm > grace_cutoff:
|
||||
# Свежий объект — возможно in-flight upload; не трогаем.
|
||||
continue
|
||||
try:
|
||||
s3.delete_object(key)
|
||||
orphan_deleted += 1
|
||||
log.info("event=orphan_deleted key=%s", key)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
log.error("event=orphan_delete_failed key=%s type=%s", key, type(exc).__name__)
|
||||
|
||||
# Проверяем обратную сторону: метаданные без объекта.
|
||||
for key in known:
|
||||
if s3.head_object(key) is None:
|
||||
missing += 1
|
||||
log.warning("event=missing_object key=%s", key)
|
||||
|
||||
return {
|
||||
"scanned": scanned,
|
||||
"orphan_deleted": orphan_deleted,
|
||||
"missing": missing,
|
||||
"known": len(known),
|
||||
}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
init_pool()
|
||||
interval = _interval()
|
||||
log.info("event=cleanup_start interval_s=%s grace_s=%s", interval, _grace())
|
||||
try:
|
||||
while True:
|
||||
try:
|
||||
stats = _run_once()
|
||||
log.info(
|
||||
"event=cleanup_pass scanned=%s known=%s orphan_deleted=%s missing=%s",
|
||||
stats["scanned"], stats["known"],
|
||||
stats["orphan_deleted"], stats["missing"],
|
||||
)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
log.error("event=cleanup_failed type=%s", type(exc).__name__)
|
||||
time.sleep(interval)
|
||||
finally:
|
||||
close_pool()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,143 @@
|
||||
"""Хранилище сессий. Redis (основной режим, lab2 level 4) или PostgreSQL (fallback).
|
||||
|
||||
Ключевое: при недоступности Redis поднимаем RuntimeError("redis_unavailable"),
|
||||
чтобы main.py отдал 503 unavailable, а не 500 internal_error.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import Optional
|
||||
from uuid import UUID
|
||||
|
||||
from ..models.schemas import User
|
||||
from . import db as _db
|
||||
|
||||
try:
|
||||
import redis as _redis
|
||||
except ImportError: # pragma: no cover
|
||||
_redis = None
|
||||
|
||||
|
||||
_SESSION_PREFIX = "sess:"
|
||||
|
||||
|
||||
def now_utc() -> datetime:
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
def _store() -> str:
|
||||
return os.environ.get("SESSION_STORE", "redis").strip().lower()
|
||||
|
||||
|
||||
def _redis_client():
|
||||
"""Возвращает подключённый клиент Redis или поднимает RuntimeError.
|
||||
|
||||
RuntimeError("redis_unavailable: ...") ловит main.runtime_error_handler → 503.
|
||||
"""
|
||||
if _redis is None:
|
||||
raise RuntimeError("redis_unavailable: redis library is not installed")
|
||||
url = os.environ.get("REDIS_URL", "redis://redis:6379/0")
|
||||
try:
|
||||
client = _redis.from_url(
|
||||
url,
|
||||
decode_responses=True,
|
||||
socket_timeout=2.0,
|
||||
socket_connect_timeout=2.0,
|
||||
)
|
||||
client.ping()
|
||||
return client
|
||||
except _redis.RedisError as exc:
|
||||
raise RuntimeError("redis_unavailable: %s" % type(exc).__name__) from exc
|
||||
|
||||
|
||||
def _user_key(user_id: UUID) -> str:
|
||||
return str(user_id)
|
||||
|
||||
|
||||
def create_session(user_id: UUID, ttl_seconds: int) -> tuple[str, datetime]:
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires_at = now_utc() + timedelta(seconds=ttl_seconds)
|
||||
if _store() == "redis":
|
||||
r = _redis_client()
|
||||
payload = json.dumps({"user_id": _user_key(user_id), "expires_at": expires_at.isoformat()})
|
||||
try:
|
||||
# SETEX: TTL — сама суть Redis-сессий
|
||||
r.setex(_SESSION_PREFIX + token, ttl_seconds, payload)
|
||||
except _redis.RedisError as exc:
|
||||
raise RuntimeError("redis_unavailable: %s" % type(exc).__name__) from exc
|
||||
else:
|
||||
with _db.connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"INSERT INTO sessions (token, user_id, expires_at) VALUES (%s, %s, %s)",
|
||||
(token, user_id, expires_at),
|
||||
)
|
||||
conn.commit()
|
||||
return token, expires_at
|
||||
|
||||
|
||||
def get_session_user(token: str) -> Optional[User]:
|
||||
if _store() == "redis":
|
||||
r = _redis_client()
|
||||
try:
|
||||
raw = r.get(_SESSION_PREFIX + token)
|
||||
except _redis.RedisError as exc:
|
||||
raise RuntimeError("redis_unavailable: %s" % type(exc).__name__) from exc
|
||||
if raw is None:
|
||||
return None
|
||||
try:
|
||||
data = json.loads(raw)
|
||||
user_id = UUID(data["user_id"])
|
||||
expires_at = datetime.fromisoformat(data["expires_at"])
|
||||
except Exception:
|
||||
return None
|
||||
if expires_at <= now_utc():
|
||||
try:
|
||||
r.delete(_SESSION_PREFIX + token)
|
||||
except _redis.RedisError:
|
||||
pass
|
||||
return None
|
||||
return _load_user(user_id)
|
||||
# postgres fallback
|
||||
with _db.connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at"
|
||||
" FROM sessions s JOIN users u ON u.id = s.user_id"
|
||||
" WHERE s.token = %s",
|
||||
(token,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
if row[4] <= now_utc():
|
||||
cur.execute("DELETE FROM sessions WHERE token = %s", (token,))
|
||||
conn.commit()
|
||||
return None
|
||||
return User(id=row[0], username=row[1], display_name=row[2], created_at=row[3])
|
||||
|
||||
|
||||
def revoke_session(token: str) -> None:
|
||||
if _store() == "redis":
|
||||
r = _redis_client()
|
||||
try:
|
||||
r.delete(_SESSION_PREFIX + token)
|
||||
except _redis.RedisError as exc:
|
||||
raise RuntimeError("redis_unavailable: %s" % type(exc).__name__) from exc
|
||||
return
|
||||
with _db.connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute("DELETE FROM sessions WHERE token = %s", (token,))
|
||||
conn.commit()
|
||||
|
||||
|
||||
def _load_user(user_id: UUID) -> Optional[User]:
|
||||
with _db.connection() as conn:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
|
||||
(user_id,),
|
||||
)
|
||||
row = cur.fetchone()
|
||||
return User(id=row[0], username=row[1], display_name=row[2], created_at=row[3]) if row else None
|
||||
@@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Единая команда запуска собственных тестов.
|
||||
Запускает: test_negative.py, test_concurrency.py.
|
||||
Публичный smoke запускается отдельно."""
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
|
||||
|
||||
def run_one(script, base_url):
|
||||
print("=== %s ===" % script.name)
|
||||
proc = subprocess.run(
|
||||
[sys.executable, str(script), "--base-url", base_url],
|
||||
cwd=str(HERE),
|
||||
)
|
||||
if proc.returncode != 0:
|
||||
print("FAIL: %s" % script.name)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def main():
|
||||
import argparse
|
||||
p = argparse.ArgumentParser(description="Lab1 student tests (level 4)")
|
||||
p.add_argument("--base-url", default="http://localhost:8080")
|
||||
args = p.parse_args()
|
||||
|
||||
ok = True
|
||||
for script in ("lab1_test_negative.py", "lab1_test_concurrency.py"):
|
||||
if not run_one(HERE / script, args.base_url):
|
||||
ok = False
|
||||
if not ok:
|
||||
raise SystemExit(1)
|
||||
print("PASS: all student tests (level 4) passed")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,70 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Конкурентный тест: 100 сообщений от 10 клиентов -> ровно 100 уникальных.
|
||||
Проверяет защиту in-memory структур от гонок (RLock)."""
|
||||
import sys
|
||||
import threading
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, arguments, check, run # noqa: E402
|
||||
|
||||
TOTAL_MESSAGES = 100
|
||||
CLIENTS = 10
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments("Lab1 concurrency safety")
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
path = "/api/v1/chats/" + chat["id"]
|
||||
|
||||
# Каждый «клиент» — свой actor (alice/bob) для реалистичной конкуренции
|
||||
actors = [alice, bob]
|
||||
barrier = threading.Barrier(CLIENTS)
|
||||
|
||||
def worker(worker_id):
|
||||
local = Client(args.base_url, args.ca_file, timeout=15)
|
||||
actor = actors[worker_id % len(actors)]
|
||||
barrier.wait() # синхронный старт всех потоков
|
||||
produced = []
|
||||
for i in range(TOTAL_MESSAGES // CLIENTS):
|
||||
text = "c-%02d-%02d-%s" % (worker_id, i, uuid.uuid4().hex[:8])
|
||||
msg = local.message(actor, chat, text)["json"]
|
||||
produced.append(msg)
|
||||
return produced
|
||||
|
||||
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
|
||||
results = list(pool.map(worker, range(CLIENTS)))
|
||||
|
||||
all_ids = [m["id"] for chunk in results for m in chunk]
|
||||
check(len(all_ids) == TOTAL_MESSAGES,
|
||||
"expected %d message ids, got %d" % (TOTAL_MESSAGES, len(all_ids)))
|
||||
check(len(set(all_ids)) == TOTAL_MESSAGES,
|
||||
"duplicate message ids under concurrency: %d unique" % len(set(all_ids)))
|
||||
|
||||
# Читаем всю историю через пагинацию
|
||||
collected = []
|
||||
cursor = None
|
||||
from urllib.parse import quote
|
||||
for _ in range(50):
|
||||
q = path + "/messages?limit=100"
|
||||
if cursor:
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=alice, schema="MessagePage")["json"]
|
||||
collected.extend(m["id"] for m in page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
check(len(collected) == TOTAL_MESSAGES,
|
||||
"stored messages: %d, expected %d" % (len(collected), TOTAL_MESSAGES))
|
||||
check(len(set(collected)) == TOTAL_MESSAGES,
|
||||
"stored messages contain duplicates: %d unique" % len(set(collected)))
|
||||
|
||||
print("PASS: lab1 concurrency: %d messages from %d clients, "
|
||||
"%d unique stored and readable" % (TOTAL_MESSAGES, CLIENTS, len(set(collected))))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,194 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Трек 1 (оценка 5). Предел in-memory архитектуры.
|
||||
|
||||
Гипотеза: на больших историях список сообщений при чтении каждый раз
|
||||
копируется и сортируется под RLock, что ухудшает p95/p99 при росте
|
||||
истории. Убираем сортировку на чтении (append сохраняет порядок) и
|
||||
сравниваем "до/после" при тех же лимитах.
|
||||
|
||||
Эксперимент: >=3 размера истории (H) x >=3 уровня конкуренции (C).
|
||||
Метрики: successful RPS, доля ошибок, p50/p95/p99 только успешных
|
||||
запросов, RSS процесса API (читается через docker stats или /proc).
|
||||
|
||||
Скрипт не меняет API; использует те же публичные клиенты из tests/.
|
||||
Stdlib only, Python 3.9+.
|
||||
"""
|
||||
import json
|
||||
import math
|
||||
import statistics
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, Failure, arguments, check, run # noqa: E402
|
||||
|
||||
|
||||
# --- профиль эксперимента -------------------------------------------------
|
||||
HISTORY_SIZES = [100, 1000, 5000] # >=3 размера истории
|
||||
CONCURRENCY_LEVELS = [1, 4, 16] # >=3 уровня конкуренции
|
||||
DURATION_SECONDS = 10 # на каждую точку (H, C)
|
||||
API_CONTAINER = "mtusi-messenger-lab1" # имя контейнера для docker stats
|
||||
|
||||
|
||||
def rss_mb(container: str):
|
||||
"""RSS процесса API в МБ через docker stats --no-stream."""
|
||||
try:
|
||||
out = subprocess.run(
|
||||
["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", container],
|
||||
capture_output=True, text=True, timeout=10,
|
||||
)
|
||||
if out.returncode != 0:
|
||||
return None
|
||||
# Пример: "120.5MiB / 1GiB"
|
||||
used = out.stdout.strip().split("/")[0].strip()
|
||||
if used.endswith("MiB"):
|
||||
return round(float(used[:-3]), 2)
|
||||
if used.endswith("GiB"):
|
||||
return round(float(used[:-3]) * 1024, 2)
|
||||
if used.endswith("KiB"):
|
||||
return round(float(used[:-3]) / 1024, 2)
|
||||
except Exception:
|
||||
return None
|
||||
return None
|
||||
|
||||
|
||||
def seed_history(c, actor, chat, count, workers=16):
|
||||
"""Заполняет историю до count сообщений параллельно."""
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
def one(i):
|
||||
local = Client(c.base, timeout=15)
|
||||
local.message(actor, chat, "seed-%06d-%s" % (i, uuid.uuid4().hex[:6]))
|
||||
with ThreadPoolExecutor(max_workers=workers) as pool:
|
||||
list(pool.map(one, range(count)))
|
||||
|
||||
|
||||
def measure_read_point(c, chat, actor, duration, concurrency):
|
||||
"""Закрытый контур: параллельно читаем GET /messages?limit=100."""
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages?limit=100"
|
||||
barrier = threading.Barrier(concurrency)
|
||||
latencies, errors = [], 0
|
||||
errors_lock = threading.Lock()
|
||||
|
||||
def worker(_):
|
||||
nonlocal errors
|
||||
local = Client(c.base, timeout=15)
|
||||
barrier.wait()
|
||||
deadline = time.monotonic() + duration
|
||||
local_lat = []
|
||||
while time.monotonic() < deadline:
|
||||
start = time.monotonic()
|
||||
try:
|
||||
local.call("GET", path, actor=actor, schema="MessagePage")
|
||||
local_lat.append(time.monotonic() - start)
|
||||
except Failure:
|
||||
with errors_lock:
|
||||
errors += 1
|
||||
return local_lat
|
||||
|
||||
started = time.monotonic()
|
||||
with ThreadPoolExecutor(max_workers=concurrency) as pool:
|
||||
results = list(pool.map(worker, range(concurrency)))
|
||||
elapsed = time.monotonic() - started
|
||||
|
||||
for chunk in results:
|
||||
latencies.extend(chunk)
|
||||
latencies.sort()
|
||||
|
||||
def pct(p):
|
||||
if not latencies:
|
||||
return None
|
||||
return round(1000 * latencies[max(0, math.ceil(p * len(latencies)) - 1)], 3)
|
||||
|
||||
total = len(latencies) + errors
|
||||
return {
|
||||
"history_size": None, # заполнит вызывающий
|
||||
"concurrency": concurrency,
|
||||
"duration_s": round(elapsed, 3),
|
||||
"successful": len(latencies),
|
||||
"errors": errors,
|
||||
"error_ratio": round(errors / total, 6) if total else None,
|
||||
"rps": round(len(latencies) / elapsed, 3),
|
||||
"latency_ms": {"p50": pct(.50), "p95": pct(.95), "p99": pct(.99)},
|
||||
}
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments("Трек 1: предел in-memory архитектуры")
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
|
||||
report = {"lab": 1, "track": 1, "profile": {
|
||||
"history_sizes": HISTORY_SIZES,
|
||||
"concurrency_levels": CONCURRENCY_LEVELS,
|
||||
"duration_seconds": DURATION_SECONDS,
|
||||
"note": "closed-loop; клиент ограничивает throughput; RSS — docker stats",
|
||||
}, "points": []}
|
||||
|
||||
for h in HISTORY_SIZES:
|
||||
# Досеиваем историю до h (bootstrap уже создал часть).
|
||||
# Считаем число сообщений в истории.
|
||||
# Предыдущая версия: limit=1 - возвращает только одну страницу и далее считает её длину страницы за длину всей истории,
|
||||
# Текущая версия: limit=100 - делаем полный обход истории по курсору => реальное число сообщений
|
||||
have = 0
|
||||
cursor = None
|
||||
from urllib.parse import quote
|
||||
while True:
|
||||
q = path + "?limit=100"
|
||||
if cursor:
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=alice, schema="MessagePage")["json"]
|
||||
have += len(page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
if have < h:
|
||||
seed_history(c, alice, chat, h - have)
|
||||
|
||||
for con in CONCURRENCY_LEVELS:
|
||||
point = measure_read_point(c, chat, alice, DURATION_SECONDS, con)
|
||||
point["history_size"] = h
|
||||
point["rss_mb"] = rss_mb(API_CONTAINER)
|
||||
report["points"].append(point)
|
||||
print(json.dumps(point, ensure_ascii=False))
|
||||
|
||||
out = Path("evidence/lab1_track1_load.json")
|
||||
out.parent.mkdir(parents=True, exist_ok=True)
|
||||
out.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
|
||||
print("PASS: track1 load matrix saved to", out)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Дополнительный CLI: --container для имени Docker-контейнера.
|
||||
import argparse
|
||||
p = argparse.ArgumentParser(add_help=False)
|
||||
p.add_argument("--container", default=API_CONTAINER)
|
||||
extra, _ = p.parse_known_args()
|
||||
# Прокидываем в namespace аргументов arguments() через env-подобный трюк.
|
||||
sys.argv = [a for a in sys.argv if not a.startswith("--container")]
|
||||
import os
|
||||
os.environ.setdefault("TRACK1_CONTAINER", extra.container)
|
||||
|
||||
def _bind_container(ns):
|
||||
ns.container = os.environ.get("TRACK1_CONTAINER", API_CONTAINER)
|
||||
return ns
|
||||
|
||||
# Патчим arguments, чтобы добавить --container.
|
||||
import client as _client # noqa: E402
|
||||
_orig_arguments = _client.arguments
|
||||
|
||||
def _arguments(description, configure=None):
|
||||
def cfg(parser):
|
||||
if configure:
|
||||
configure(parser)
|
||||
parser.add_argument("--container", default=API_CONTAINER)
|
||||
return _orig_arguments(description, cfg)
|
||||
|
||||
_client.arguments = _arguments
|
||||
run(main)
|
||||
@@ -0,0 +1,100 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Негативные сценарии lab1: неверный JSON, чужой чат, пустое сообщение,
|
||||
дубликат username, обход нескольких страниц. Stdlib only, Python 3.9+."""
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, Failure, arguments, check, run # noqa: E402
|
||||
|
||||
|
||||
def _raw_call(base_url, method, path, body=None, headers=None):
|
||||
"""Сырой запрос для проверки malformed JSON (client.py всегда сериализует)."""
|
||||
url = base_url.rstrip("/") + path
|
||||
data = body if isinstance(body, (bytes, type(None))) else body.encode("utf-8")
|
||||
req = urllib.request.Request(url, data=data, headers=headers or {}, method=method)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=10) as resp:
|
||||
return resp.status, resp.read()
|
||||
except urllib.error.HTTPError as e:
|
||||
return e.code, e.read()
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments("Lab1 negative scenarios")
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
path = "/api/v1/chats/" + chat["id"]
|
||||
|
||||
# 1. Дубликат username -> 409
|
||||
c.call("POST", "/api/v1/users", 409, body=alice["registration"])
|
||||
|
||||
# 2. Неверный JSON (malformed) -> 400
|
||||
status, _ = _raw_call(
|
||||
c.base,
|
||||
"POST",
|
||||
"/api/v1/users",
|
||||
body=b"{not json at all",
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
check(status == 400, "malformed JSON must be 400, got %s" % status)
|
||||
|
||||
# 3. Лишние поля -> 400
|
||||
c.call(
|
||||
"POST",
|
||||
"/api/v1/users",
|
||||
400,
|
||||
body={"username": "extra_user_x", "display_name": "X", "unexpected": True},
|
||||
)
|
||||
|
||||
# 4. Неверный тип -> 400
|
||||
c.call("POST", "/api/v1/users", 400, body={"username": 123, "display_name": "X"})
|
||||
|
||||
# 5. Пустое / пробельное сообщение -> 400
|
||||
c.call("POST", path + "/messages", 400, actor=alice, body={"text": ""})
|
||||
c.call("POST", path + "/messages", 400, actor=alice, body={"text": " "})
|
||||
|
||||
# 6. Чужой чат -> 404 (не 403)
|
||||
c.call("GET", path, 404, actor=eve)
|
||||
c.call("GET", path + "/messages", 404, actor=eve)
|
||||
c.call("POST", path + "/messages", 404, actor=eve, body={"text": "чужое"})
|
||||
|
||||
# 7. Пагинация: обход нескольких страниц без потерь и дублей
|
||||
texts = ["p-%02d" % i for i in range(7)]
|
||||
for t in texts:
|
||||
c.message(alice, chat, t)
|
||||
collected = []
|
||||
cursor = None
|
||||
seen_cursors = set()
|
||||
for _ in range(20): # предохранитель от бесконечного цикла
|
||||
q = path + "/messages?limit=2"
|
||||
if cursor:
|
||||
from urllib.parse import quote
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=bob, schema="MessagePage")["json"]
|
||||
collected.extend(m["text"] for m in page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
check(cursor not in seen_cursors, "cursor loop detected")
|
||||
seen_cursors.add(cursor)
|
||||
check(len(collected) == len(texts), "pagination lost messages: %d != %d" % (len(collected), len(texts)))
|
||||
check(len(set(collected)) == len(collected), "pagination duplicated messages")
|
||||
check(collected == texts, "pagination order/contents mismatch")
|
||||
|
||||
# 8. Некорректный limit -> 400
|
||||
c.call("GET", path + "/messages?limit=0", 400, actor=alice)
|
||||
c.call("GET", path + "/messages?limit=101", 400, actor=alice)
|
||||
|
||||
# 9. Неизвестный X-User-Id -> 401
|
||||
c.call("GET", "/api/v1/users/me", 401, headers={"X-User-Id": str(uuid.uuid4())})
|
||||
|
||||
print("PASS: lab1 negative scenarios (dup, malformed JSON, extra fields, "
|
||||
"wrong type, empty text, foreign chat, pagination, bad limit, unknown user)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,587 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Уровень 4 lab2: expiry TTL, конкурентная регистрация, EXPLAIN, недоступность Redis/PostgreSQL.
|
||||
|
||||
Перед запуском:
|
||||
1) в .env выставить SESSION_TTL_SECONDS=5
|
||||
2) docker compose --env-file .env up -d --force-recreate api
|
||||
3) docker exec mtuci-redis redis-cli flushdb
|
||||
4) python student-tests/test_lab2_level4.py --base-url http://localhost:8080
|
||||
5) перед smoke/persistence вернуть SESSION_TTL_SECONDS=3600 и снова up -d --force-recreate api
|
||||
|
||||
Порядок тестов: тяжёлые по данным и конкурентные — ДО expiry-теста,
|
||||
потому что при коротком TTL любой долгий шаг съедает окно жизни сессии.
|
||||
Expiry-тест запускается последним и использует свежие сессии.
|
||||
|
||||
test_explain не зависит от TTL вообще: он сидирует данные напрямую
|
||||
через psql и проверяет план SQL-запроса, а не HTTP-слой.
|
||||
|
||||
test_chat_rollback проверяет транзакционную границу create_chat: он
|
||||
запускает патч-скрипт ВНУТРИ контейнера API (там есть psycopg и
|
||||
DATABASE_URL), monkey-patch-ит psycopg.Cursor.executemany так, чтобы
|
||||
INSERT в chat_members упал ПОСЛЕ успешного INSERT в chats. Затем через
|
||||
psql проверяется, что ни chat, ни chat_members не сохранились.
|
||||
"""
|
||||
import base64
|
||||
import datetime as dt
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, Failure, arguments, check, run # noqa: E402
|
||||
|
||||
# Имя compose-сети проекта: mtuci2026lab2_default (зафиксировано в compose.yaml networks.default.name).
|
||||
COMPOSE_NETWORK = os.environ.get("COMPOSE_NETWORK", "mtuci2026lab2_default")
|
||||
|
||||
# Имя контейнера API (зафиксировано в compose.yaml container_name).
|
||||
API_CONTAINER = os.environ.get("API_CONTAINER", "mtuci-messenger-lab2")
|
||||
|
||||
|
||||
# ---------- 1. Конкурентная регистрация одинакового username ----------
|
||||
def test_concurrent_registration(c):
|
||||
"""Один и тот же username с 8 потоков — ровно одна 201, остальные 409.
|
||||
|
||||
Проверяем ФАКТИЧЕСКИЕ HTTP-коды, а не факт исключения: timeout, 500
|
||||
или неверный формат ответа должны проваливать тест, а не выдаваться
|
||||
за ожидаемый конфликт. Дополнительно сверяем, что в БД создана
|
||||
ровно одна строка пользователя.
|
||||
"""
|
||||
username = "race_" + uuid.uuid4().hex[:10]
|
||||
password = "T3st-" + uuid.uuid4().hex
|
||||
body = {"username": username, "display_name": "Race", "password": password}
|
||||
results = []
|
||||
lock = threading.Lock()
|
||||
|
||||
def one(_):
|
||||
local = Client(c.base, timeout=10)
|
||||
try:
|
||||
r = local.call("POST", "/api/v1/users", (201, 409),
|
||||
body=body, schema="User" if True else None)
|
||||
# schema валидируется только для 2xx; при 409 приходит Error.
|
||||
status = r["status"]
|
||||
except Failure as exc:
|
||||
# Любая иная ошибка (timeout, 500, bad schema) — это не 409.
|
||||
status = "failure:%s" % exc
|
||||
with lock:
|
||||
results.append(status)
|
||||
|
||||
with ThreadPoolExecutor(max_workers=8) as pool:
|
||||
list(pool.map(one, range(8)))
|
||||
|
||||
ok = [r for r in results if r == 201]
|
||||
conflict = [r for r in results if r == 409]
|
||||
bad = [r for r in results if r not in (201, 409)]
|
||||
check(not bad, "unexpected results under concurrent registration: %s" % results)
|
||||
check(len(ok) == 1, "expected exactly one 201, got %s" % results)
|
||||
check(len(conflict) == 7, "expected seven 409, got %s" % results)
|
||||
|
||||
# В БД должна быть ровно одна строка с этим username.
|
||||
dsn = _read_dsn()
|
||||
rows = _scalar(dsn, "SELECT count(*) FROM users WHERE username = '%s';" % username)
|
||||
check(int(rows) == 1,
|
||||
"ожидалась ровно одна строка users для %s, получено %s" % (username, rows))
|
||||
|
||||
|
||||
# ---------- 2. EXPLAIN на реальной БД ----------
|
||||
def _read_dsn() -> str:
|
||||
dsn = os.environ.get("DATABASE_URL")
|
||||
if not dsn:
|
||||
env_file = Path(__file__).resolve().parents[1] / ".env"
|
||||
if env_file.is_file():
|
||||
for line in env_file.read_text(encoding="utf-8").splitlines():
|
||||
line = line.strip()
|
||||
if line.startswith("DATABASE_URL="):
|
||||
dsn = line.split("=", 1)[1].strip()
|
||||
break
|
||||
check(dsn, "DATABASE_URL не найден ни в окружении, ни в .env")
|
||||
# Postgres доступен только внутри compose-сети; одноразовые psql-контейнеры
|
||||
# запускаются в этой же сети, поэтому имя хоста postgres резолвится как есть.
|
||||
return dsn
|
||||
|
||||
|
||||
def _psql(dsn_in_container: str, sql: str) -> str:
|
||||
r = subprocess.run(
|
||||
[
|
||||
"docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"postgres:18-alpine",
|
||||
"psql", dsn_in_container, "-tA", "-c", sql,
|
||||
],
|
||||
capture_output=True, text=True, timeout=120,
|
||||
)
|
||||
return r.stdout + r.stderr
|
||||
|
||||
|
||||
def _scalar(dsn: str, sql: str) -> str:
|
||||
r = subprocess.run(
|
||||
[
|
||||
"docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"postgres:18-alpine",
|
||||
"psql", dsn, "-tA", "-v", "ON_ERROR_STOP=1", "-c", sql,
|
||||
],
|
||||
capture_output=True, text=True, timeout=120,
|
||||
)
|
||||
check(r.returncode == 0, "psql failed:\n" + r.stdout + r.stderr)
|
||||
return r.stdout.strip().splitlines()[-1]
|
||||
|
||||
|
||||
def test_explain(c):
|
||||
"""EXPLAIN (ANALYZE, BUFFERS) истории сообщений на >=10 000 строк.
|
||||
|
||||
Методичка: индекс истории обоснован запросом и EXPLAIN на >=10 000
|
||||
сообщениях. На пустой таблице планировщик выбирает Seq Scan, поэтому
|
||||
тест сам доводит messages до >=10 000 строк и делает ANALYZE.
|
||||
|
||||
Данные сидируются напрямую через psql, без API: тест не зависит от
|
||||
SESSION_TTL_SECONDS и скорости scrypt. Это корректно, потому что
|
||||
EXPLAIN проверяет план SQL-запроса, а не HTTP-слой.
|
||||
"""
|
||||
dsn_in_container = _read_dsn()
|
||||
|
||||
# Смотрим, сколько строк уже есть.
|
||||
have_raw = _psql(dsn_in_container, "SELECT count(*) FROM messages;")
|
||||
have = int(have_raw.strip().splitlines()[-1])
|
||||
print(" в таблице messages сейчас: %d строк" % have)
|
||||
|
||||
target_total = 10_000
|
||||
if have < target_total:
|
||||
need = target_total - have
|
||||
print(" сидируем %d сообщений напрямую через psql ..." % need)
|
||||
|
||||
# Один чат: берём существующий или создаём минимальный.
|
||||
# gen_random_uuid() доступен в PG13+ без расширений.
|
||||
seed_sql = """
|
||||
DO $$
|
||||
DECLARE
|
||||
v_user UUID;
|
||||
v_chat UUID;
|
||||
BEGIN
|
||||
SELECT id INTO v_user FROM users LIMIT 1;
|
||||
IF v_user IS NULL THEN
|
||||
v_user := gen_random_uuid();
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES (v_user, 'seed_' || substr(v_user::text, 1, 8), 'Seed',
|
||||
'scrypt$16384$8$1$00$00', now());
|
||||
END IF;
|
||||
|
||||
SELECT id INTO v_chat FROM chats LIMIT 1;
|
||||
IF v_chat IS NULL THEN
|
||||
v_chat := gen_random_uuid();
|
||||
INSERT INTO chats (id, title, created_at) VALUES (v_chat, 'Seed chat', now());
|
||||
INSERT INTO chat_members (chat_id, user_id) VALUES (v_chat, v_user);
|
||||
END IF;
|
||||
|
||||
-- Доливаем ровно need строк в этот чат.
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(), v_chat, v_user,
|
||||
'seed-' || g, now() - (g || ' milliseconds')::interval
|
||||
FROM generate_series(1, %d) AS g;
|
||||
END $$;
|
||||
""" % need
|
||||
r = subprocess.run(
|
||||
[
|
||||
"docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"postgres:18-alpine",
|
||||
"psql", dsn_in_container, "-c", seed_sql,
|
||||
],
|
||||
capture_output=True, text=True, timeout=120,
|
||||
)
|
||||
seed_out = r.stdout + r.stderr
|
||||
check("ERROR" not in seed_out, "сидирование не удалось:\n" + seed_out)
|
||||
|
||||
# ANALYZE обязателен: без него планировщик не знает реальных размеров.
|
||||
_psql(dsn_in_container, "ANALYZE messages;")
|
||||
_psql(dsn_in_container, "ANALYZE chat_members;")
|
||||
_psql(dsn_in_container, "ANALYZE chats;")
|
||||
print(" сидирование завершено")
|
||||
|
||||
# EXPLAIN по САМОМУ БОЛЬШОМУ чату, чтобы планировщик имел основания
|
||||
# выбрать индекс, а не Seq Scan.
|
||||
biggest = _psql(
|
||||
dsn_in_container,
|
||||
"SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1;",
|
||||
).strip().splitlines()[-1]
|
||||
check(biggest and len(biggest) >= 32, "не удалось выбрать самый большой чат: %r" % biggest)
|
||||
|
||||
sql = (
|
||||
"EXPLAIN (ANALYZE, BUFFERS) "
|
||||
"SELECT id, chat_id, sender_id, text, created_at FROM messages "
|
||||
"WHERE chat_id = '%s' "
|
||||
"ORDER BY created_at, id LIMIT 51;" % biggest
|
||||
)
|
||||
r = subprocess.run(
|
||||
[
|
||||
"docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"postgres:18-alpine",
|
||||
"psql", dsn_in_container, "-c", sql,
|
||||
],
|
||||
capture_output=True, text=True, timeout=120,
|
||||
)
|
||||
out = r.stdout + r.stderr
|
||||
print("EXPLAIN (фрагмент):")
|
||||
for line in out.splitlines()[:12]:
|
||||
print(" ", line)
|
||||
check("Index" in out or "Bitmap Index" in out or "idx_messages_chat_created" in out,
|
||||
"EXPLAIN не показал использования индекса:\n" + out)
|
||||
|
||||
|
||||
# ---------- 3. Rollback составной операции create_chat ----------
|
||||
def test_chat_rollback(c):
|
||||
"""Проверяем, что при падении INSERT в chat_members ПОСЛЕ успешного
|
||||
INSERT в chats не остаётся ни строки чата, ни частичного членства.
|
||||
|
||||
Как добиться ошибки именно на вставке участников, а не на предварительной
|
||||
проверке unknown_member? Проверка `SELECT id FROM users WHERE id = ANY(...)`
|
||||
в postgres.py отсекает неизвестных до INSERT. Значит, нужен сбой именно
|
||||
в executemany.
|
||||
|
||||
Решение: запускаем патч-скрипт ВНУТРИ контейнера API через docker exec —
|
||||
там уже установлен psycopg и доступен DATABASE_URL. Скрипт monkey-patch-ит
|
||||
psycopg.Cursor.executemany так, чтобы он бросил исключение, и вызывает
|
||||
storage.create_chat с двумя реально существующими пользователями.
|
||||
Транзакция дойдёт до INSERT в chats, упадёт на executemany и должна
|
||||
откатиться.
|
||||
|
||||
После этого через psql проверяем:
|
||||
- в таблице chats нет строки с этим title;
|
||||
- в таблице chat_members нет строк с этим chat_id;
|
||||
- через API GET /api/v1/chats пользователь не видит этот чат.
|
||||
"""
|
||||
dsn = _read_dsn()
|
||||
|
||||
# Готовим двух валидных пользователей через API, чтобы FK был валиден.
|
||||
suffix = uuid.uuid4().hex[:10]
|
||||
alice_username = "rb_a_" + suffix
|
||||
bob_username = "rb_b_" + suffix
|
||||
alice_password = "T3st-" + uuid.uuid4().hex
|
||||
bob_password = "T3st-" + uuid.uuid4().hex
|
||||
alice = c.call("POST", "/api/v1/users", 201,
|
||||
body={"username": alice_username, "display_name": "RB-A",
|
||||
"password": alice_password},
|
||||
schema="User")["json"]
|
||||
bob = c.call("POST", "/api/v1/users", 201,
|
||||
body={"username": bob_username, "display_name": "RB-B",
|
||||
"password": bob_password},
|
||||
schema="User")["json"]
|
||||
|
||||
# Уникальный title, чтобы точно найти строку, если rollback не сработает.
|
||||
marker_title = "rollback-chat-" + uuid.uuid4().hex
|
||||
|
||||
# Скрипт запускается ВНУТРИ контейнера API: там есть psycopg и DATABASE_URL.
|
||||
# Патчит executemany так, чтобы он упал после успешного INSERT в chats.
|
||||
patch_script = r'''
|
||||
import os, sys, psycopg
|
||||
from uuid import UUID
|
||||
|
||||
_orig = psycopg.Cursor.executemany
|
||||
def boom(self, *args, **kwargs):
|
||||
raise RuntimeError("patched_executemany_failure")
|
||||
psycopg.Cursor.executemany = boom
|
||||
|
||||
sys.path.insert(0, "/app/src")
|
||||
from app.storage.postgres import storage
|
||||
|
||||
try:
|
||||
storage.create_chat(os.environ["RB_TITLE"],
|
||||
[UUID(os.environ["RB_ALICE"]), UUID(os.environ["RB_BOB"])])
|
||||
except RuntimeError as exc:
|
||||
if "patched_executemany_failure" in str(exc):
|
||||
print("PATCHED_FAILURE_OK"); sys.exit(0)
|
||||
raise
|
||||
except Exception as exc:
|
||||
print("UNEXPECTED:%s:%s" % (type(exc).__name__, exc)); sys.exit(2)
|
||||
print("NO_FAILURE"); sys.exit(3)
|
||||
'''
|
||||
|
||||
proc = subprocess.run(
|
||||
["docker", "exec",
|
||||
"-e", "RB_TITLE=" + marker_title,
|
||||
"-e", "RB_ALICE=" + alice["id"],
|
||||
"-e", "RB_BOB=" + bob["id"],
|
||||
API_CONTAINER,
|
||||
"python", "-c", patch_script],
|
||||
capture_output=True, text=True, timeout=60,
|
||||
)
|
||||
out = (proc.stdout + proc.stderr).strip()
|
||||
print(" rollback-процесс: exit=%d, out=%r" % (proc.returncode, out[:200]))
|
||||
check("PATCHED_FAILURE_OK" in out,
|
||||
"не удалось вызвать ошибку именно на executemany: %s" % out)
|
||||
|
||||
# Проверяем в БД: ни chats, ни chat_members с этим маркером не осталось.
|
||||
chats_count = _scalar(
|
||||
dsn,
|
||||
"SELECT count(*) FROM chats WHERE title = '%s';" % marker_title,
|
||||
)
|
||||
check(int(chats_count) == 0,
|
||||
"rollback не сработал: строка chats с title=%s осталась (%s)" % (marker_title, chats_count))
|
||||
|
||||
members_count = _scalar(
|
||||
dsn,
|
||||
"SELECT count(*) FROM chat_members cm "
|
||||
"JOIN chats c ON c.id = cm.chat_id "
|
||||
"WHERE c.title = '%s';" % marker_title,
|
||||
)
|
||||
check(int(members_count) == 0,
|
||||
"rollback не сработал: остались строки chat_members (%s)" % members_count)
|
||||
|
||||
# Дополнительно: у пользователя нет чата с таким title через API.
|
||||
cred = base64.b64encode((alice_username + ":" + alice_password).encode()).decode()
|
||||
session = c.call("POST", "/api/v1/auth/sessions", 201,
|
||||
headers={"Authorization": "Basic " + cred},
|
||||
schema="Session")["json"]
|
||||
listed = c.call("GET", "/api/v1/chats?limit=100",
|
||||
headers={"Authorization": "Bearer " + session["token"]},
|
||||
schema="ChatPage")["json"]
|
||||
check(all(item["title"] != marker_title for item in listed["items"]),
|
||||
"чат с маркером rollback виден в списке чатов пользователя")
|
||||
|
||||
|
||||
# ---------- 4. Недоступность Redis (с действующим токеном) ----------
|
||||
def _compose(action, service="redis"):
|
||||
return subprocess.run(
|
||||
["docker", "compose", "--env-file", ".env", action, service],
|
||||
capture_output=True, text=True, timeout=60,
|
||||
)
|
||||
|
||||
|
||||
def _wait_ready(c, timeout=60):
|
||||
deadline = time.monotonic() + timeout
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
c.call("GET", "/health/ready", 200)
|
||||
return
|
||||
except Failure:
|
||||
time.sleep(1)
|
||||
raise Failure("API не вернулся в ready за %d секунд после восстановления зависимости" % timeout)
|
||||
|
||||
|
||||
def test_redis_unavailable(c):
|
||||
"""Останавливаем Redis: /health/ready → 503, действующий токен не работает.
|
||||
|
||||
Важно: используем ЗАРАНЕЕ полученную рабочую сессию, а не заведомо
|
||||
неправильный Bearer. Иначе 401 мог бы получиться и без обращения к Redis.
|
||||
После восстановления Redis прежняя сессия снова должна работать.
|
||||
"""
|
||||
print(" (проверка недоступности Redis: docker compose stop redis на ~6 секунд)")
|
||||
|
||||
# Готовим рабочую сессию ДО остановки Redis.
|
||||
suffix = uuid.uuid4().hex[:10]
|
||||
username = "redis_" + suffix
|
||||
password = "T3st-" + uuid.uuid4().hex
|
||||
c.call("POST", "/api/v1/users", 201,
|
||||
body={"username": username, "display_name": "Redis", "password": password},
|
||||
schema="User")
|
||||
cred = base64.b64encode((username + ":" + password).encode()).decode()
|
||||
session = c.call("POST", "/api/v1/auth/sessions", 201,
|
||||
headers={"Authorization": "Basic " + cred},
|
||||
schema="Session")["json"]
|
||||
token = session["token"]
|
||||
|
||||
# Контроль: до остановки Redis токен рабочий.
|
||||
me = c.call("GET", "/api/v1/users/me", 200,
|
||||
headers={"Authorization": "Bearer " + token},
|
||||
schema="User")["json"]
|
||||
check(me["username"] == username, "токен должен принадлежать созданному пользователю")
|
||||
|
||||
stopped = _compose("stop", "redis")
|
||||
check(stopped.returncode == 0,
|
||||
"docker compose stop redis не сработал:\n" + (stopped.stdout + stopped.stderr))
|
||||
|
||||
try:
|
||||
time.sleep(3)
|
||||
# /health/ready должен стать 503.
|
||||
ready = c.call("GET", "/health/ready", 503)
|
||||
check(ready["status"] == 503, "readiness must be 503 without Redis")
|
||||
|
||||
# Действующий токен при мёртвом Redis не должен давать доступ:
|
||||
# сервер не может проверить сессию и обязан ответить 503.
|
||||
r = c.call("GET", "/api/v1/users/me", (401, 503),
|
||||
headers={"Authorization": "Bearer " + token})
|
||||
check(r["status"] == 503,
|
||||
"запрос с действующим токеном при мёртвом Redis должен быть 503, получено %s" % r["status"])
|
||||
finally:
|
||||
# Только восстановление. Никаких return/break/continue внутри finally.
|
||||
started = _compose("start", "redis")
|
||||
check(started.returncode == 0,
|
||||
"docker compose start redis не сработал:\n" + (started.stdout + started.stderr))
|
||||
|
||||
# Ждём готовности — УЖЕ ВНЕ finally.
|
||||
_wait_ready(c, timeout=60)
|
||||
|
||||
# Прежний токен снова должен работать: сессия пережила рестарт Redis (AOF).
|
||||
me2 = c.call("GET", "/api/v1/users/me", 200,
|
||||
headers={"Authorization": "Bearer " + token},
|
||||
schema="User")["json"]
|
||||
check(me2["id"] == me["id"], "прежняя сессия должна снова работать после восстановления Redis")
|
||||
|
||||
|
||||
# ---------- 5. Недоступность PostgreSQL ----------
|
||||
def test_postgres_unavailable(c):
|
||||
"""Останавливаем PostgreSQL: /health/ready → 503, действующий токен → 503.
|
||||
|
||||
Проверяем:
|
||||
- /health/ready возвращает 503;
|
||||
- запрос с действующим токеном возвращает 503 в пределах таймаута;
|
||||
- анонимный запрос не получает доступ;
|
||||
- после запуска БД прежний токен работает, ранее записанные данные сохранены.
|
||||
Восстановление БД выполняется в finally, чтобы не оставлять стенд остановленным.
|
||||
"""
|
||||
print(" (проверка недоступности PostgreSQL: docker compose stop postgres на ~6 секунд)")
|
||||
|
||||
# Готовим рабочую сессию и сообщение ДО остановки БД.
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
marker = "pgdown-" + uuid.uuid4().hex
|
||||
sent = c.message(alice, chat, marker)["json"]
|
||||
|
||||
# Контроль: до остановки всё работает.
|
||||
c.call("GET", "/api/v1/users/me", 200, actor=alice, schema="User")
|
||||
|
||||
stopped = _compose("stop", "postgres")
|
||||
check(stopped.returncode == 0,
|
||||
"docker compose stop postgres не сработал:\n" + (stopped.stdout + stopped.stderr))
|
||||
|
||||
try:
|
||||
time.sleep(3)
|
||||
# /health/ready должен стать 503.
|
||||
ready = c.call("GET", "/health/ready", 503)
|
||||
check(ready["status"] == 503, "readiness must be 503 without PostgreSQL")
|
||||
|
||||
# Запрос с действующим токеном: 503 в пределах таймаута.
|
||||
t0 = time.monotonic()
|
||||
r = c.call("GET", "/api/v1/users/me", 503, actor=alice)
|
||||
elapsed = time.monotonic() - t0
|
||||
check(r["status"] == 503,
|
||||
"запрос с действующим токеном при мёртвой БД должен быть 503")
|
||||
# statement_timeout=5000 + пул timeout=5.0: укладываемся в разумный предел.
|
||||
check(elapsed < 30, "ответ при мёртвой БД занял %.1f c, ожидался в пределах таймаута" % elapsed)
|
||||
|
||||
# Анонимный запрос не получает доступ.
|
||||
anon = c.call("GET", "/api/v1/users/me", (401, 503))
|
||||
check(anon["status"] in (401, 503),
|
||||
"анонимный запрос при мёртвой БД должен быть 401 или 503, получено %s" % anon["status"])
|
||||
finally:
|
||||
started = _compose("start", "postgres")
|
||||
check(started.returncode == 0,
|
||||
"docker compose start postgres не сработал:\n" + (started.stdout + started.stderr))
|
||||
|
||||
# Ждём готовности — УЖЕ ВНЕ finally.
|
||||
_wait_ready(c, timeout=60)
|
||||
|
||||
# Прежний токен работает, ранее записанное сообщение сохранено.
|
||||
c.call("GET", "/api/v1/users/me", 200, actor=alice, schema="User")
|
||||
messages = c.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100",
|
||||
actor=bob, schema="MessagePage")["json"]["items"]
|
||||
check(any(m["id"] == sent["id"] and m["text"] == marker for m in messages),
|
||||
"ранее записанное сообщение не найдено после восстановления PostgreSQL")
|
||||
|
||||
|
||||
# ---------- 6. Expiry TTL ----------
|
||||
def test_short_ttl_expiry(c):
|
||||
"""TTL=5. Проверяем полный цикл: токен валиден -> истекает -> 401.
|
||||
|
||||
Идёт ПОСЛЕДНИМ: при коротком TTL любая долгая подготовка съедает
|
||||
окно жизни сессии, поэтому соседние тесты работают раньше.
|
||||
"""
|
||||
suffix = uuid.uuid4().hex[:10]
|
||||
username = "ttl_" + suffix
|
||||
password = "T3st-" + uuid.uuid4().hex
|
||||
user = c.call("POST", "/api/v1/users", 201,
|
||||
body={"username": username, "display_name": "TTL", "password": password},
|
||||
schema="User")["json"]
|
||||
cred = base64.b64encode((username + ":" + password).encode()).decode()
|
||||
session = c.call("POST", "/api/v1/auth/sessions", 201,
|
||||
headers={"Authorization": "Basic " + cred},
|
||||
schema="Session")["json"]
|
||||
token = session["token"]
|
||||
|
||||
# Контроль: сервер выдал короткий TTL, иначе тест бессмыслен.
|
||||
expires_at = dt.datetime.fromisoformat(session["expires_at"].replace("Z", "+00:00"))
|
||||
ttl_actual = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds()
|
||||
check(3.0 <= ttl_actual <= 10,
|
||||
"SESSION_TTL_SECONDS не короткий (получено %.1f c). "
|
||||
"Поставьте, пожалуйста, SESSION_TTL_SECONDS=5 в .env и перезапустите API (команда: docker compose --env-file .env up -d api)." % ttl_actual)
|
||||
|
||||
# До истечения токен должен работать.
|
||||
me = c.call("GET", "/api/v1/users/me", 200,
|
||||
headers={"Authorization": "Bearer " + token},
|
||||
schema="User")["json"]
|
||||
check(me["id"] == user["id"], "token must identify its owner before expiry")
|
||||
|
||||
# Ждём гарантированного истечения TTL + запас.
|
||||
remaining = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds()
|
||||
time.sleep(max(remaining, 0.0) + 1.0)
|
||||
|
||||
# Истёкший токен — 401.
|
||||
c.call("GET", "/api/v1/users/me", 401,
|
||||
headers={"Authorization": "Bearer " + token})
|
||||
|
||||
# Второй вход тем же пользователем даёт рабочий токен: истёк именно
|
||||
# первый токен, а не пользователь/хранилище целиком.
|
||||
session2 = c.call("POST", "/api/v1/auth/sessions", 201,
|
||||
headers={"Authorization": "Basic " + cred},
|
||||
schema="Session")["json"]
|
||||
c.call("GET", "/api/v1/users/me", 200,
|
||||
headers={"Authorization": "Bearer " + session2["token"]},
|
||||
schema="User")
|
||||
|
||||
|
||||
# ---------- main ----------
|
||||
def main():
|
||||
args = arguments("Lab2 level 4 checks", configure=_configure)
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
|
||||
# Порядок и режимы:
|
||||
# --only-expiry — ТОЛЬКО expiry-тест (запускать при SESSION_TTL_SECONDS=5)
|
||||
# --skip-expiry — все тяжёлые тесты, без expiry (при SESSION_TTL_SECONDS=3600)
|
||||
# без флагов — сначала тяжёлые, expiry последним (при SESSION_TTL_SECONDS=5
|
||||
# это сработает только если тяжёлые тесты успевают до истечения TTL,
|
||||
# поэтому на практике используйте --only-expiry/--skip-expiry)
|
||||
run_expiry = not args.skip_expiry
|
||||
run_others = not args.only_expiry
|
||||
|
||||
if run_others:
|
||||
print("=== test_concurrent_registration ===")
|
||||
test_concurrent_registration(c)
|
||||
print("PASS: concurrent registration produces exactly one user")
|
||||
|
||||
print("=== test_chat_rollback ===")
|
||||
test_chat_rollback(c)
|
||||
print("PASS: create_chat rollback leaves no chat and no partial membership")
|
||||
|
||||
print("=== test_explain ===")
|
||||
test_explain(c)
|
||||
print("PASS: EXPLAIN uses idx_messages_chat_created")
|
||||
|
||||
print("=== test_redis_unavailable ===")
|
||||
test_redis_unavailable(c)
|
||||
print("PASS: readiness 503 без Redis, действующий токен отвергнут, затем восстановление")
|
||||
|
||||
print("=== test_postgres_unavailable ===")
|
||||
test_postgres_unavailable(c)
|
||||
print("PASS: readiness 503 без PostgreSQL, данные и сессия сохранены")
|
||||
|
||||
if run_expiry:
|
||||
print("=== test_short_ttl_expiry ===")
|
||||
test_short_ttl_expiry(c)
|
||||
print("PASS: session valid before TTL, expires after TTL, 401 on expired token")
|
||||
|
||||
print("PASS: all requested lab2 level-4 checks passed")
|
||||
|
||||
|
||||
def _configure(p):
|
||||
p.add_argument("--only-expiry", action="store_true",
|
||||
help="запустить только expiry-тест (SESSION_TTL_SECONDS=5)")
|
||||
p.add_argument("--skip-expiry", action="store_true",
|
||||
help="запустить всё, кроме expiry (SESSION_TTL_SECONDS=3600)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,465 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Трек 2 (оценка 5). План запроса, стоимость записи, backup/restore, RPO.
|
||||
|
||||
Шаги:
|
||||
1. Сидируем >=100 000 сообщений с неравномерными чатами (track2_seed.sql).
|
||||
2. Сравниваем 3 варианта индексов на большом и маленьком чате:
|
||||
- baseline (нет индекса) -> Seq Scan
|
||||
- (chat_id) -> Bitmap/Index + Sort
|
||||
- (chat_id, created_at, id) -> Index Scan без Sort (текущий)
|
||||
Снимаем: план (EXPLAIN ANALYZE BUFFERS), время, shared hit/read.
|
||||
3. Стоимость записи: INSERT 10 000 строк на каждом варианте -> время вставки,
|
||||
pg_indexes_size, pg_total_relation_size.
|
||||
4. Backup/restore: pg_dump -Fc, restore в новый контейнер postgres:18-alpine,
|
||||
сверка COUNT(*), COUNT(*) GROUP BY chat_id и 100 случайных сообщений.
|
||||
5. Границы потери данных: во время pg_dump через API пишем новые сообщения,
|
||||
после restore проверяем, что их нет.
|
||||
|
||||
Все psql-вызовы идут через docker run postgres:18-alpine в compose-сети проекта
|
||||
(--network mtuci2026lab2_default), DSN указывает на хост postgres.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import random
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
import base64
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, Failure, arguments, check, run # noqa: E402
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
EVIDENCE = ROOT / "evidence"
|
||||
EVIDENCE.mkdir(exist_ok=True)
|
||||
|
||||
SEED_SQL = ROOT / "student-tests" / "track2_seed.sql"
|
||||
|
||||
# Имя compose-сети проекта: mtuci2026lab2_default (зафиксировано в compose.yaml networks.default.name).
|
||||
COMPOSE_NETWORK = os.environ.get("COMPOSE_NETWORK", "mtuci2026lab2_default")
|
||||
|
||||
|
||||
# ---------- helpers ----------
|
||||
def _read_dsn() -> str:
|
||||
dsn = os.environ.get("DATABASE_URL")
|
||||
if not dsn:
|
||||
env_file = ROOT / ".env"
|
||||
if env_file.is_file():
|
||||
for line in env_file.read_text(encoding="utf-8").splitlines():
|
||||
line = line.strip()
|
||||
if line.startswith("DATABASE_URL="):
|
||||
dsn = line.split("=", 1)[1].strip()
|
||||
break
|
||||
check(dsn, "DATABASE_URL не найден ни в окружении, ни в .env")
|
||||
# Postgres доступен только внутри compose-сети; одноразовые psql/pg_dump
|
||||
# контейнеры запускаются в этой же сети, имя хоста postgres резолвится как есть.
|
||||
return dsn
|
||||
|
||||
|
||||
def _psql(dsn: str, sql: str, extra=None):
|
||||
cmd = [
|
||||
"docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"postgres:18-alpine",
|
||||
"psql", dsn, "-tA", "-v", "ON_ERROR_STOP=1",
|
||||
]
|
||||
if extra:
|
||||
cmd += extra
|
||||
cmd += ["-c", sql]
|
||||
return subprocess.run(cmd, capture_output=True, text=True, timeout=300)
|
||||
|
||||
|
||||
def _psql_file(dsn: str, path: Path):
|
||||
cmd = [
|
||||
"docker", "run", "--rm", "-i",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-v", f"{path}:/seed.sql:ro",
|
||||
"postgres:18-alpine",
|
||||
"psql", dsn, "-v", "ON_ERROR_STOP=1", "-f", "/seed.sql",
|
||||
]
|
||||
return subprocess.run(cmd, capture_output=True, text=True, timeout=600)
|
||||
|
||||
|
||||
def _scalar(dsn: str, sql: str):
|
||||
r = _psql(dsn, sql)
|
||||
check(r.returncode == 0, "psql failed:\n" + r.stdout + r.stderr)
|
||||
return r.stdout.strip().splitlines()[-1]
|
||||
|
||||
|
||||
# ---------- 1. seed ----------
|
||||
def step_seed(dsn: str):
|
||||
print("=== 1. seed ===")
|
||||
before = int(_scalar(dsn, "SELECT count(*) FROM messages;"))
|
||||
print(" messages before:", before)
|
||||
r = _psql_file(dsn, SEED_SQL)
|
||||
check(r.returncode == 0, "seed failed:\n" + r.stdout + r.stderr)
|
||||
after = int(_scalar(dsn, "SELECT count(*) FROM messages;"))
|
||||
print(" messages after:", after)
|
||||
check(after >= 100_000, "seed не довёл до 100 000 (получено %d)" % after)
|
||||
dist = _psql(dsn, "SELECT chat_id, count(*) FROM messages GROUP BY chat_id ORDER BY count(*) DESC;")
|
||||
print(" распределение по чатам:\n" + dist.stdout)
|
||||
return after
|
||||
|
||||
|
||||
# ---------- 2. explain ----------
|
||||
def _big_and_small(dsn):
|
||||
big = _scalar(dsn, "SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1;")
|
||||
small = _scalar(dsn, "SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) ASC LIMIT 1;")
|
||||
return big, small
|
||||
|
||||
|
||||
def _chat_size(dsn: str, chat_id: str) -> int:
|
||||
return int(_scalar(dsn, "SELECT count(*) FROM messages WHERE chat_id = '%s';" % chat_id))
|
||||
|
||||
|
||||
def _explain(dsn: str, chat_id: str, label: str):
|
||||
# Берём средний created_at, чтобы keyset реально резал историю
|
||||
mid = _scalar(dsn,
|
||||
"SELECT created_at FROM messages WHERE chat_id = '%s' ORDER BY created_at, id OFFSET (SELECT count(*)/2 FROM messages WHERE chat_id = '%s') LIMIT 1;" % (chat_id, chat_id))
|
||||
sql = (
|
||||
"EXPLAIN (ANALYZE, BUFFERS) "
|
||||
"SELECT id, chat_id, sender_id, text, created_at FROM messages "
|
||||
"WHERE chat_id = '%s' AND (created_at, id) > ('%s', '00000000-0000-0000-0000-000000000000') "
|
||||
"ORDER BY created_at, id LIMIT 51;" % (chat_id, mid)
|
||||
)
|
||||
r = _psql(dsn, sql)
|
||||
check(r.returncode == 0, "EXPLAIN failed:\n" + r.stdout + r.stderr)
|
||||
out = r.stdout
|
||||
print("\n--- EXPLAIN %s (chat=%s...) ---" % (label, chat_id[:8]))
|
||||
for line in out.splitlines():
|
||||
print(" ", line)
|
||||
return out
|
||||
|
||||
|
||||
def _drop_indexes(dsn):
|
||||
_psql(dsn, "DROP INDEX IF EXISTS idx_messages_chat_created;")
|
||||
_psql(dsn, "DROP INDEX IF EXISTS idx_messages_chat_only;")
|
||||
|
||||
|
||||
def _format_section(title: str, chat_size: int, plan: str, note: str = "") -> str:
|
||||
"""Собирает один раздел отчёта в формате образца."""
|
||||
head = "## %s\n\n" % title
|
||||
if note:
|
||||
head += note.rstrip() + "\n\n"
|
||||
return head + "```\n" + plan.rstrip() + "\n```\n"
|
||||
|
||||
|
||||
def step_explain(dsn: str, total_messages: int):
|
||||
print("=== 2. EXPLAIN 3 варианта ===")
|
||||
big, small = _big_and_small(dsn)
|
||||
big_size = _chat_size(dsn, big)
|
||||
small_size = _chat_size(dsn, small)
|
||||
|
||||
# (1) без индекса
|
||||
_drop_indexes(dsn)
|
||||
_psql(dsn, "ANALYZE messages;")
|
||||
no_index_big = _explain(dsn, big, "no_index/big")
|
||||
no_index_small = _explain(dsn, small, "no_index/small")
|
||||
|
||||
# (2) только (chat_id)
|
||||
_psql(dsn, "CREATE INDEX idx_messages_chat_only ON messages (chat_id);")
|
||||
_psql(dsn, "ANALYZE messages;")
|
||||
chat_only_big = _explain(dsn, big, "chat_only/big")
|
||||
chat_only_small = _explain(dsn, small, "chat_only/small")
|
||||
|
||||
# (3) полный рабочий
|
||||
_psql(dsn, "DROP INDEX IF EXISTS idx_messages_chat_only;")
|
||||
_psql(dsn, "CREATE INDEX idx_messages_chat_created ON messages (chat_id, created_at, id);")
|
||||
_psql(dsn, "ANALYZE messages;")
|
||||
full_big = _explain(dsn, big, "full/big")
|
||||
full_small = _explain(dsn, small, "full/small")
|
||||
|
||||
# Заголовок отчёта — как в образце
|
||||
parts = []
|
||||
parts.append(
|
||||
"# Трек 2. EXPLAIN (ANALYZE, BUFFERS): 3 варианта индекса\n\n"
|
||||
"Данные: %d сообщений, неравномерные чаты. "
|
||||
"Запрос: `SELECT ... FROM messages WHERE chat_id = <id> AND (created_at, id) > (<середина>, …) "
|
||||
"ORDER BY created_at, id LIMIT 51`.\n"
|
||||
"Большой чат ~%d, маленький чат ~%d.\n" % (total_messages, big_size, small_size)
|
||||
)
|
||||
|
||||
parts.append(_format_section(
|
||||
"1. Без индекса, большой чат", big_size, no_index_big,
|
||||
"`Parallel Seq Scan` по всей таблице, затем `Sort`."))
|
||||
parts.append(_format_section(
|
||||
"2. Без индекса, маленький чат", small_size, no_index_small,
|
||||
"Тот же `Parallel Seq Scan` по всей таблице."))
|
||||
parts.append(_format_section(
|
||||
"3. Индекс (chat_id), большой чат", big_size, chat_only_big,
|
||||
"`Bitmap Index Scan` по `idx_messages_chat_only`, затем `Bitmap Heap Scan` и `Sort`."))
|
||||
parts.append(_format_section(
|
||||
"4. Индекс (chat_id), маленький чат", small_size, chat_only_small,
|
||||
"`Index Scan using idx_messages_chat_only` + `Sort`."))
|
||||
parts.append(_format_section(
|
||||
"5. Полный индекс (chat_id, created_at, id), большой чат", big_size, full_big,
|
||||
"`Index Scan using idx_messages_chat_created`, **без `Sort`**."))
|
||||
parts.append(_format_section(
|
||||
"6. Полный индекс (chat_id, created_at, id), маленький чат", small_size, full_small,
|
||||
"`Index Scan` без `Sort`."))
|
||||
|
||||
(EVIDENCE / "lab2_track2_explain.md").write_text(
|
||||
"\n".join(parts), encoding="utf-8")
|
||||
|
||||
return {"big_chat": big, "small_chat": small}
|
||||
|
||||
|
||||
# ---------- 3. write cost ----------
|
||||
def _index_sizes(dsn: str):
|
||||
out = _scalar(dsn, "SELECT pg_size_pretty(pg_indexes_size('messages')) || '|' || pg_size_pretty(pg_total_relation_size('messages'));")
|
||||
idx, total = out.split("|")
|
||||
return idx.strip(), total.strip()
|
||||
|
||||
|
||||
def step_write_cost(dsn: str):
|
||||
print("=== 3. Стоимость записи: 10 000 INSERT на каждом варианте ===")
|
||||
seed_user = _scalar(dsn, "SELECT id FROM users LIMIT 1;")
|
||||
seed_chat = _scalar(dsn, "SELECT id FROM chats WHERE title = 'seed-chat-4' LIMIT 1;")
|
||||
|
||||
results = []
|
||||
for name, setup in (
|
||||
("no_index", lambda: _drop_indexes(dsn)),
|
||||
("chat_only", lambda: (_psql(dsn, "DROP INDEX IF EXISTS idx_messages_chat_created;"),
|
||||
_psql(dsn, "CREATE INDEX IF NOT EXISTS idx_messages_chat_only ON messages (chat_id);"))),
|
||||
("full", lambda: (_psql(dsn, "DROP INDEX IF EXISTS idx_messages_chat_only;"),
|
||||
_psql(dsn, "CREATE INDEX IF NOT EXISTS idx_messages_chat_created ON messages (chat_id, created_at, id);"))),
|
||||
):
|
||||
setup()
|
||||
# мерить именно вставку 10k
|
||||
t0 = time.monotonic()
|
||||
r = _psql(dsn,
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text, created_at) "
|
||||
"SELECT gen_random_uuid(), '%s', '%s', 'wc-%s-' || g, now() "
|
||||
"FROM generate_series(1, 10000) AS g;" % (seed_chat, seed_user, name))
|
||||
dt = time.monotonic() - t0
|
||||
check(r.returncode == 0, "insert failed:\n" + r.stdout + r.stderr)
|
||||
idx, total = _index_sizes(dsn)
|
||||
results.append({"variant": name, "insert_10000_s": round(dt, 3),
|
||||
"indexes_size": idx, "total_size": total})
|
||||
print(" %-10s insert=%.3fs idx=%s total=%s" % (name, dt, idx, total))
|
||||
|
||||
(EVIDENCE / "lab2_track2_write_cost.json").write_text(
|
||||
json.dumps(results, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
|
||||
return results
|
||||
|
||||
|
||||
# ---------- 4. backup/restore ----------
|
||||
def step_backup_restore(dsn: str):
|
||||
print("=== 4. backup -> restore -> сверка ===")
|
||||
out_file = EVIDENCE / "lab2_track2_dump.dump"
|
||||
if out_file.exists():
|
||||
out_file.unlink()
|
||||
|
||||
# pg_dump через docker run (использует образ PG 18), в compose-сети
|
||||
t0 = time.monotonic()
|
||||
r = subprocess.run(
|
||||
["docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-v", f"{EVIDENCE}:/out",
|
||||
"postgres:18-alpine",
|
||||
"pg_dump", "-Fc", "-f", "/out/lab2_track2_dump.dump", dsn],
|
||||
capture_output=True, text=True, timeout=600,
|
||||
)
|
||||
dump_time = time.monotonic() - t0
|
||||
check(r.returncode == 0, "pg_dump failed:\n" + r.stdout + r.stderr)
|
||||
size = out_file.stat().st_size
|
||||
print(" dump size = %.1f MiB, time = %.2fs" % (size / 1024 / 1024, dump_time))
|
||||
|
||||
# новый контейнер как отдельное хранилище — в той же compose-сети,
|
||||
# порт наружу не публикуем
|
||||
restore_container = "mtuci-pg-restore"
|
||||
subprocess.run(["docker", "rm", "-f", restore_container], capture_output=True)
|
||||
subprocess.run(
|
||||
["docker", "run", "-d", "--name", restore_container,
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-e", "POSTGRES_PASSWORD=restore", "-e", "POSTGRES_USER=postgres",
|
||||
"-e", "POSTGRES_DB=high_load_messenger",
|
||||
"postgres:18-alpine"],
|
||||
capture_output=True, text=True,
|
||||
)
|
||||
# ждём готовности
|
||||
deadline = time.monotonic() + 60
|
||||
while time.monotonic() < deadline:
|
||||
c = subprocess.run(["docker", "exec", restore_container, "pg_isready", "-U", "postgres"],
|
||||
capture_output=True, text=True)
|
||||
if c.returncode == 0:
|
||||
break
|
||||
time.sleep(1)
|
||||
else:
|
||||
raise Failure("restore container не поднялся")
|
||||
|
||||
# pg_restore -c (clean) на пустую БД; restore-контейнер доступен по имени
|
||||
# в compose-сети
|
||||
t0 = time.monotonic()
|
||||
r = subprocess.run(
|
||||
["docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-v", f"{EVIDENCE}:/in",
|
||||
"postgres:18-alpine",
|
||||
"pg_restore", "-d", "postgresql://postgres:restore@mtuci-pg-restore:5432/high_load_messenger",
|
||||
"--no-owner", "--no-privileges", "/in/lab2_track2_dump.dump"],
|
||||
capture_output=True, text=True, timeout=600,
|
||||
)
|
||||
restore_time = time.monotonic() - t0
|
||||
print(" pg_restore exit=%d, time=%.2fs" % (r.returncode, restore_time))
|
||||
check(r.returncode == 0, "pg_restore failed:\n" + r.stdout + r.stderr)
|
||||
|
||||
# Сверка: сравнение с исходной БД через docker exec psql внутри restore-контейнера
|
||||
def q_restore(sql):
|
||||
c = subprocess.run(["docker", "exec", restore_container, "psql", "-U", "postgres",
|
||||
"-d", "high_load_messenger", "-tA", "-c", sql],
|
||||
capture_output=True, text=True, timeout=120)
|
||||
check(c.returncode == 0, "restore psql failed:\n" + c.stdout + c.stderr)
|
||||
return c.stdout.strip().splitlines()[-1]
|
||||
|
||||
orig_total = int(_scalar(dsn, "SELECT count(*) FROM messages;"))
|
||||
rest_total = int(q_restore("SELECT count(*) FROM messages;"))
|
||||
check(orig_total == rest_total, "COUNT(*) mismatch: %d vs %d" % (orig_total, rest_total))
|
||||
|
||||
orig_dist = _scalar(dsn,
|
||||
"SELECT string_agg(chat_id::text || ':' || c, ',' ORDER BY chat_id) "
|
||||
"FROM (SELECT chat_id, count(*) c FROM messages GROUP BY chat_id) t;")
|
||||
rest_dist = q_restore(
|
||||
"SELECT string_agg(chat_id::text || ':' || c, ',' ORDER BY chat_id) "
|
||||
"FROM (SELECT chat_id, count(*) c FROM messages GROUP BY chat_id) t;")
|
||||
check(orig_dist == rest_dist, "распределение по чатам не совпадает")
|
||||
|
||||
# 100 случайных сообщений
|
||||
ids_raw = _scalar(dsn, "SELECT string_agg(id::text, ',') FROM (SELECT id FROM messages ORDER BY random() LIMIT 100) t;")
|
||||
ids = ids_raw.split(",")
|
||||
check(len(ids) == 100, "не удалось выбрать 100 id")
|
||||
ids_list = ",".join("'%s'" % i for i in ids)
|
||||
orig_rows = _scalar(dsn,
|
||||
"SELECT string_agg(id::text || '|' || text, E'\n' ORDER BY id) FROM messages WHERE id IN (%s);" % ids_list)
|
||||
rest_rows = q_restore(
|
||||
"SELECT string_agg(id::text || '|' || text, E'\n' ORDER BY id) FROM messages WHERE id IN (%s);" % ids_list)
|
||||
check(orig_rows == rest_rows, "100 случайных сообщений различаются")
|
||||
|
||||
print(" OK: COUNT, распределение по чатам и 100 случайных сообщений совпадают")
|
||||
print(" RTO (pg_restore) = %.2fs, dump = %.1f MiB" % (restore_time, size / 1024 / 1024))
|
||||
|
||||
(EVIDENCE / "lab2_track2_restore.txt").write_text(
|
||||
"Track 2 restore\n"
|
||||
"dump_time_s=%.3f\ndump_size_bytes=%d\nrestore_time_s=%.3f\n"
|
||||
"count_original=%d\ncount_restored=%d\n"
|
||||
"dist_match=true\nrandom100_match=true\n"
|
||||
% (dump_time, size, restore_time, orig_total, rest_total),
|
||||
encoding="utf-8")
|
||||
|
||||
# чистим restore-контейнер (volume анонимный)
|
||||
subprocess.run(["docker", "rm", "-f", restore_container], capture_output=True)
|
||||
return {"dump_time_s": round(dump_time, 3), "restore_time_s": round(restore_time, 3),
|
||||
"dump_bytes": size, "count": orig_total}
|
||||
|
||||
|
||||
# ---------- 5. RPO ----------
|
||||
def step_rpo(dsn: str, base_url: str, ca_file):
|
||||
print("=== 5. RPO: запись во время pg_dump ===")
|
||||
c = Client(base_url, ca_file)
|
||||
|
||||
# Данные и сессии готовим заранее, до дампа.
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
|
||||
# Контроль: сессия должна быть валидна, иначе 401 — это не RPO.
|
||||
me = c.call("GET", "/api/v1/users/me", 200, actor=alice, schema="User")
|
||||
check(me["status"] == 200, "сессия должна быть валидна перед RPO-тестом")
|
||||
|
||||
marker = "rpo-" + uuid.uuid4().hex
|
||||
# Запускаем pg_dump
|
||||
out_file = EVIDENCE / "lab2_track2_rpo.dump"
|
||||
if out_file.exists():
|
||||
out_file.unlink()
|
||||
|
||||
# pg_dump: тот же приём, что в шаге 4, в compose-сети.
|
||||
proc = subprocess.Popen(
|
||||
["docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-v", f"{EVIDENCE}:/out",
|
||||
"postgres:18-alpine",
|
||||
"pg_dump", "-Fc", "-f", "/out/lab2_track2_rpo.dump", dsn],
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
|
||||
)
|
||||
time.sleep(1.0) # снапшот уже снят
|
||||
|
||||
# Свежий логин прямо перед записью: не зависим от TTL старой сессии.
|
||||
cred = base64.b64encode(
|
||||
(alice["registration"]["username"] + ":" +
|
||||
alice["registration"]["password"]).encode()
|
||||
).decode()
|
||||
fresh = c.call("POST", "/api/v1/auth/sessions", 201,
|
||||
headers={"Authorization": "Basic " + cred},
|
||||
schema="Session")["json"]
|
||||
alice_for_write = {"id": alice["id"], "user": alice["user"], "token": fresh["token"]}
|
||||
|
||||
written = c.message(alice_for_write, chat, marker)["json"]
|
||||
code = proc.wait(timeout=300)
|
||||
check(code == 0, "pg_dump для RPO упал")
|
||||
|
||||
# Временный restore-контейнер: в compose-сети, без публикации портов.
|
||||
restore_container = "mtuci-pg-rpo"
|
||||
subprocess.run(["docker", "rm", "-f", restore_container], capture_output=True)
|
||||
subprocess.run(
|
||||
["docker", "run", "-d", "--name", restore_container,
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-e", "POSTGRES_PASSWORD=restore", "-e", "POSTGRES_USER=postgres",
|
||||
"-e", "POSTGRES_DB=high_load_messenger",
|
||||
"postgres:18-alpine"],
|
||||
capture_output=True, text=True,
|
||||
)
|
||||
|
||||
deadline = time.monotonic() + 60
|
||||
while time.monotonic() < deadline:
|
||||
c2 = subprocess.run(["docker", "exec", restore_container, "pg_isready", "-U", "postgres"],
|
||||
capture_output=True, text=True)
|
||||
if c2.returncode == 0:
|
||||
break
|
||||
time.sleep(1)
|
||||
else:
|
||||
raise Failure("restore container для RPO не поднялся")
|
||||
|
||||
# pg_restore идёт в restore-контейнер по имени в compose-сети.
|
||||
r = subprocess.run(
|
||||
["docker", "run", "--rm",
|
||||
"--network", COMPOSE_NETWORK,
|
||||
"-v", f"{EVIDENCE}:/in",
|
||||
"postgres:18-alpine",
|
||||
"pg_restore", "-d",
|
||||
"postgresql://postgres:restore@mtuci-pg-rpo:5432/high_load_messenger",
|
||||
"--no-owner", "--no-privileges", "/in/lab2_track2_rpo.dump"],
|
||||
capture_output=True, text=True, timeout=600,
|
||||
)
|
||||
check(r.returncode == 0, "pg_restore для RPO упал:\n" + r.stdout + r.stderr)
|
||||
|
||||
c3 = subprocess.run(["docker", "exec", restore_container, "psql", "-U", "postgres",
|
||||
"-d", "high_load_messenger", "-tA", "-c",
|
||||
"SELECT count(*) FROM messages WHERE id = '%s';" % written["id"]],
|
||||
capture_output=True, text=True)
|
||||
present = int(c3.stdout.strip().splitlines()[-1])
|
||||
check(present == 0, "сообщение, записанное во время дампа, попало в дамп (RPO не 0)")
|
||||
print(" OK: сообщение %s записано после старта дампа и в restore отсутствует" % written["id"][:8])
|
||||
|
||||
(EVIDENCE / "lab2_track2_rpo.txt").write_text(
|
||||
"Track 2 RPO\n"
|
||||
"marker_message_id=%s\npresent_in_restore=%d\nexpected=0\n"
|
||||
% (written["id"], present),
|
||||
encoding="utf-8")
|
||||
|
||||
subprocess.run(["docker", "rm", "-f", restore_container], capture_output=True)
|
||||
|
||||
|
||||
# ---------- main ----------
|
||||
def main():
|
||||
args = arguments("Track 2: plan, write cost, backup/restore, RPO")
|
||||
dsn = _read_dsn()
|
||||
total = step_seed(dsn)
|
||||
step_explain(dsn, total)
|
||||
step_write_cost(dsn)
|
||||
step_backup_restore(dsn)
|
||||
step_rpo(dsn, args.base_url, args.ca_file)
|
||||
print("PASS: track 2 (explain + write cost + backup/restore + RPO)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,10 @@
|
||||
-- Track 2: сравнение планов и стоимости записи.
|
||||
-- Все три варианта прогоняются на одном большом чате (60k) и одном маленьком (~1400).
|
||||
|
||||
-- 0. Определяем два чата
|
||||
\set ON_ERROR_STOP on
|
||||
|
||||
SELECT id AS big_chat_id
|
||||
FROM messages GROUP BY id_chat GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1;
|
||||
|
||||
SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) ASC LIMIT 1;
|
||||
@@ -0,0 +1,81 @@
|
||||
-- Track 2: сидирование >=100 000 сообщений с неравномерными чатами.
|
||||
-- Запускать через: docker run --rm ... psql "$DATABASE_URL" -f track2_seed.sql
|
||||
-- Идемпотентно по количеству: если сообщений уже >= 100 000, ничего не делает.
|
||||
|
||||
DO $$
|
||||
DECLARE
|
||||
v_user UUID;
|
||||
v_total INT;
|
||||
v_have INT;
|
||||
v_need INT;
|
||||
v_chat UUID;
|
||||
rec RECORD;
|
||||
BEGIN
|
||||
SELECT count(*) INTO v_have FROM messages;
|
||||
v_total := 100000;
|
||||
SELECT count(*) INTO v_have FROM messages;
|
||||
IF v_have < 100000 THEN
|
||||
-- меньше 100к: догоняем до 100к
|
||||
v_need := 100000 - v_have; -- сколько добавлять за прогон
|
||||
ELSE
|
||||
v_need := 50000; -- добавляем фиксированные 50к за прогон
|
||||
END IF;
|
||||
|
||||
-- Гарантируем хотя бы одного пользователя
|
||||
SELECT id INTO v_user FROM users LIMIT 1;
|
||||
IF v_user IS NULL THEN
|
||||
v_user := gen_random_uuid();
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES (v_user, 'seed_' || substr(v_user::text, 1, 8), 'Seed',
|
||||
'scrypt$16384$8$1$00$00', now());
|
||||
END IF;
|
||||
|
||||
-- Создаём 10 чатов, если их меньше (нужны только для распределения)
|
||||
-- Неравномерность: 60k / 20k / 10k / по ~1400 на остальные 7.
|
||||
-- Считаем веса, доливаем только v_need строк.
|
||||
CREATE TEMP TABLE _plan(chat_no INT, weight INT) ON COMMIT DROP;
|
||||
INSERT INTO _plan VALUES (1, 60), (2, 20), (3, 10),
|
||||
(4, 2), (5, 2), (6, 1), (7, 1),
|
||||
(8, 1), (9, 1), (10, 1);
|
||||
|
||||
FOR rec IN SELECT * FROM _plan ORDER BY chat_no LOOP
|
||||
-- Находим/создаём chat_id для этого номера: используем title 'seed-chat-<no>'
|
||||
SELECT c.id INTO v_chat FROM chats c WHERE c.title = 'seed-chat-' || rec.chat_no LIMIT 1;
|
||||
IF v_chat IS NULL THEN
|
||||
v_chat := gen_random_uuid();
|
||||
INSERT INTO chats (id, title, created_at) VALUES (v_chat, 'seed-chat-' || rec.chat_no, now());
|
||||
END IF;
|
||||
IF NOT EXISTS (SELECT 1 FROM chat_members WHERE chat_id = v_chat AND user_id = v_user) THEN
|
||||
INSERT INTO chat_members (chat_id, user_id) VALUES (v_chat, v_user);
|
||||
END IF;
|
||||
END LOOP;
|
||||
|
||||
-- Распределяем v_need по весам (целочисленно), последний чат добирает остаток.
|
||||
DECLARE
|
||||
v_sum INT;
|
||||
v_acc INT := 0;
|
||||
v_alloc INT;
|
||||
BEGIN
|
||||
SELECT sum(weight) INTO v_sum FROM _plan;
|
||||
FOR rec IN SELECT * FROM _plan ORDER BY chat_no LOOP
|
||||
IF rec.chat_no = 10 THEN
|
||||
v_alloc := v_need - v_acc; -- остаток
|
||||
ELSE
|
||||
v_alloc := (v_need::numeric * rec.weight / v_sum)::int;
|
||||
v_acc := v_acc + v_alloc;
|
||||
END IF;
|
||||
|
||||
SELECT c.id INTO v_chat FROM chats c WHERE c.title = 'seed-chat-' || rec.chat_no LIMIT 1;
|
||||
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(), v_chat, v_user,
|
||||
'seed-' || rec.chat_no || '-' || g,
|
||||
now() - (g || ' milliseconds')::interval
|
||||
FROM generate_series(1, v_alloc) AS g;
|
||||
END LOOP;
|
||||
END;
|
||||
END $$;
|
||||
|
||||
ANALYZE messages;
|
||||
ANALYZE chat_members;
|
||||
ANALYZE chats;
|
||||
@@ -0,0 +1,223 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Уровень 4 lab3: два X-Instance-Id, идемпотентность под нагрузкой, отказ одной реплики.
|
||||
|
||||
Запуск:
|
||||
python student-tests/lab3_test_level4.py --base-url http://localhost:8080
|
||||
|
||||
Требуется рабочий стенд из compose.yaml (LB + 2 реплики + Postgres + Redis).
|
||||
"""
|
||||
import base64
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, Failure, arguments, check, run # noqa: E402
|
||||
|
||||
|
||||
# ---------- 1. Два X-Instance-Id через LB ----------
|
||||
def test_two_instances(c):
|
||||
"""Один пользователь, серия запросов — видим >=2 разных X-Instance-Id.
|
||||
|
||||
Nginx с keepalive к upstream прибивает клиента к одной реплике на всё
|
||||
время соединения. Поэтому каждый проб-запрос шлём с Connection: close,
|
||||
чтобы LB открывал новое upstream-соединение и честно распределял.
|
||||
"""
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
seen = set()
|
||||
for _ in range(60):
|
||||
r = c.call("GET", "/api/v1/users/me", actor=alice, schema="User",
|
||||
headers={"Connection": "close"})
|
||||
seen.add(r["headers"]["X-Instance-Id"])
|
||||
if len(seen) >= 2:
|
||||
break
|
||||
check(len(seen) >= 2, "LB не маршрутизирует на разные API-реплики: %s" % seen)
|
||||
print(" observed instances:", sorted(seen))
|
||||
|
||||
|
||||
# ---------- 2. Идемпотентность: один ключ на двух репликах ----------
|
||||
def test_idempotency_across_replicas(c):
|
||||
"""Одновременный POST с одним Idempotency-Key через LB создаёт ровно одно сообщение.
|
||||
|
||||
Для этого параллельно шлём 10 запросов с одним ключом из 10 потоков.
|
||||
LB распределит их по разным репликам; благодаря общей таблице
|
||||
idempotency_keys и UNIQUE-индексу, INSERT выигрывает ровно один.
|
||||
"""
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
key = "idem-" + uuid.uuid4().hex
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
body = {"text": "idem-concurrent"}
|
||||
lock = threading.Lock()
|
||||
results = []
|
||||
|
||||
def one(_):
|
||||
local = Client(c.base, timeout=10)
|
||||
try:
|
||||
r = local.call(
|
||||
"POST", path, (201, 409),
|
||||
actor=alice, body=body,
|
||||
headers={"Idempotency-Key": key},
|
||||
schema="Message",
|
||||
)
|
||||
with lock:
|
||||
results.append((r["status"], r["headers"].get("X-Instance-Id")))
|
||||
except Failure as exc:
|
||||
with lock:
|
||||
results.append(("failure:%s" % exc, None))
|
||||
|
||||
with ThreadPoolExecutor(max_workers=10) as pool:
|
||||
list(pool.map(one, range(10)))
|
||||
|
||||
ok = [r for r in results if r[0] == 201]
|
||||
conflicts = [r for r in results if r[0] == 409]
|
||||
bad = [r for r in results if r[0] not in (201, 409)]
|
||||
check(not bad, "unexpected idempotency results: %s" % results)
|
||||
check(len(ok) >= 1, "no 201 at all")
|
||||
check(len(ok) + len(conflicts) == 10, "wrong count")
|
||||
|
||||
# Проверяем в БД: ровно одно сообщение с этим текстом в этом чате.
|
||||
# Через API: читаем всю историю и считаем.
|
||||
from urllib.parse import quote
|
||||
items = []
|
||||
cursor = None
|
||||
for _ in range(50):
|
||||
q = path + "?limit=100"
|
||||
if cursor:
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=bob, schema="MessagePage")["json"]
|
||||
items.extend(m for m in page["items"] if m["text"] == "idem-concurrent")
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
check(len(items) == 1, "idempotency created %d messages, expected 1" % len(items))
|
||||
|
||||
# X-Instance-Id: запросы шли на разные реплики (проверяем, что 201 пришёл
|
||||
# хотя бы с одной, а 409 — с другой; это ожидание не обязательное, но
|
||||
# полезный сигнал, что LB реально распределяет).
|
||||
ok_instances = {r[1] for r in ok}
|
||||
conflict_instances = {r[1] for r in conflicts}
|
||||
print(" 201 instances:", ok_instances, " 409 instances:", conflict_instances)
|
||||
print(" PASS: idempotency OK, ровно одно сообщение создано")
|
||||
|
||||
|
||||
# ---------- 3. Отказ одной реплики ----------
|
||||
def test_stop_one_replica(c):
|
||||
"""Останавливаем одну реплику; вторая продолжает обслуживать запросы.
|
||||
|
||||
Восстановление делаем явно через `docker start` в finally, а ожидание
|
||||
готовности — ПОСЛЕ try/finally, чтобы не использовать return в finally.
|
||||
"""
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
|
||||
# Список контейнеров сервиса api (compose project name неизвестен,
|
||||
# ищем по image/label).
|
||||
ps = subprocess.run(
|
||||
["docker", "ps", "--filter", "label=com.docker.compose.service=api",
|
||||
"--format", "{{.ID}}"],
|
||||
capture_output=True, text=True, timeout=10,
|
||||
)
|
||||
ids = [x.strip() for x in ps.stdout.splitlines() if x.strip()]
|
||||
check(len(ids) >= 2, "нужно >=2 контейнера api, найдено %d" % len(ids))
|
||||
|
||||
target = ids[0]
|
||||
print(" останавливаем replica container:", target[:12])
|
||||
|
||||
# Готовим одно подтверждённое сообщение до отказа.
|
||||
key0 = "before-" + uuid.uuid4().hex
|
||||
first = c.call("POST", path, 201, actor=alice, body={"text": "before-fail"},
|
||||
headers={"Idempotency-Key": key0}, schema="Message")["json"]
|
||||
|
||||
# Останавливаем реплику.
|
||||
stop = subprocess.run(["docker", "stop", "-t", "5", target],
|
||||
capture_output=True, text=True, timeout=30)
|
||||
check(stop.returncode == 0, "docker stop failed: %s" % stop.stderr)
|
||||
|
||||
try:
|
||||
# Даём LB обнаружить отказ (proxy_next_upstream, max_fails=2).
|
||||
time.sleep(3)
|
||||
|
||||
# Читаем и пишем — должны попадать во вторую реплику.
|
||||
deadline = time.monotonic() + 10
|
||||
recovered = False
|
||||
seen_instances = set()
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
r = c.call("POST", path, 201, actor=alice,
|
||||
body={"text": "after-fail"},
|
||||
headers={"Idempotency-Key": "after-" + uuid.uuid4().hex},
|
||||
schema="Message")
|
||||
seen_instances.add(r["headers"].get("X-Instance-Id"))
|
||||
recovered = True
|
||||
break
|
||||
except Failure:
|
||||
time.sleep(0.5)
|
||||
check(recovered, "не удалось записать после отказа за 10 секунд")
|
||||
|
||||
# Убеждаемся, что подтверждённое до отказа сообщение доступно.
|
||||
from urllib.parse import quote
|
||||
items, cursor = [], None
|
||||
while True:
|
||||
q = path + "?limit=100"
|
||||
if cursor:
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=bob, schema="MessagePage")["json"]
|
||||
items.extend(page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
check(any(m["id"] == first["id"] for m in items),
|
||||
"подтверждённое сообщение потеряно после отказа")
|
||||
print(" after-fail instances:", seen_instances)
|
||||
print(" PASS: стенд пережил отказ одной реплики")
|
||||
finally:
|
||||
# Только восстановление реплики. Никаких return/break/continue.
|
||||
subprocess.run(["docker", "start", target],
|
||||
capture_output=True, text=True, timeout=30)
|
||||
|
||||
# Ждём готовности через LB — УЖЕ ВНЕ finally.
|
||||
deadline = time.monotonic() + 60
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
c.call("GET", "/health/ready", 200)
|
||||
# И двух реплик снова должно быть >=2.
|
||||
seen = set()
|
||||
for _ in range(30):
|
||||
seen.add(c.call("GET", "/api/v1/users/me", actor=alice,
|
||||
schema="User")["headers"]["X-Instance-Id"])
|
||||
if len(seen) >= 2:
|
||||
break
|
||||
if len(seen) >= 2:
|
||||
return
|
||||
except Failure:
|
||||
pass
|
||||
time.sleep(1)
|
||||
raise Failure("стенд не восстановился до двух реплик за 60 секунд")
|
||||
|
||||
|
||||
# ---------- main ----------
|
||||
def main():
|
||||
args = arguments("Lab3 level 4 checks")
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
|
||||
print("=== test_two_instances ===")
|
||||
test_two_instances(c)
|
||||
print("PASS: >=2 X-Instance-Id через LB")
|
||||
|
||||
print("=== test_idempotency_across_replicas ===")
|
||||
test_idempotency_across_replicas(c)
|
||||
print("PASS: идемпотентность на общих ключах")
|
||||
|
||||
print("=== test_stop_one_replica ===")
|
||||
test_stop_one_replica(c)
|
||||
print("PASS: отказ одной API-реплики обработан")
|
||||
|
||||
print("PASS: all lab3 level-4 checks passed")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,329 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Level 4 для lab4: негативные сценарии, компенсация при отказе БД, параллельные загрузки.
|
||||
|
||||
Запуск:
|
||||
$env:API_CONTAINER = (docker ps --filter "label=com.docker.compose.service=api" -q | Select-Object -First 1)
|
||||
python student-tests/lab4_test_level4.py --base-url http://localhost:8080
|
||||
|
||||
Сценарий компенсации (уровень 4):
|
||||
Останавливаем PostgreSQL → делаем upload → S3 PUT успешен, INSERT в БД
|
||||
падает → API удаляет объект из S3 (компенсация) → 503.
|
||||
После восстановления PG считаем объекты в bucket через mc — количество
|
||||
не должно вырасти. Это проверяет требование методички: «отказ между
|
||||
записью S3/БД не оставляет вечных неучтённых объектов».
|
||||
"""
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, Failure, arguments, check, run # noqa: E402
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
SAMPLE = ROOT / "tests" / "fixtures" / "sample.png"
|
||||
API_CONTAINER = os.environ.get("API_CONTAINER", "")
|
||||
COMPOSE_NETWORK = os.environ.get("COMPOSE_NETWORK", "mtuci2026lab4_default")
|
||||
MC_IMAGE = os.environ.get("MC_IMAGE", "netvark/mc:20260920")
|
||||
|
||||
|
||||
def _raw_upload(c: Client, actor, chat_id: str, filename: str, data: bytes, ctype: str):
|
||||
# filename URL-encoded: иначе urllib откажется формировать URL с NUL/CR/LF.
|
||||
qs = urllib.parse.urlencode({"filename": filename}, quote_via=urllib.parse.quote)
|
||||
url = c.base + "/api/v1/chats/" + chat_id + "/attachments?" + qs
|
||||
req = urllib.request.Request(
|
||||
url, data=data, method="POST",
|
||||
headers={
|
||||
"Authorization": "Bearer " + actor["token"],
|
||||
"Content-Type": ctype,
|
||||
},
|
||||
)
|
||||
try:
|
||||
with c.opener.open(req, timeout=30) as resp:
|
||||
import json as _json
|
||||
return resp.code, _json.loads(resp.read()), resp.headers
|
||||
except urllib.error.HTTPError as e:
|
||||
import json as _json
|
||||
body = e.read()
|
||||
try:
|
||||
return e.code, _json.loads(body), e.headers
|
||||
except Exception:
|
||||
return e.code, None, e.headers
|
||||
|
||||
|
||||
def _upload(c, actor, chat, data, filename="sample.png", ctype="image/png"):
|
||||
return _raw_upload(c, actor, chat["id"], filename, data, ctype)
|
||||
|
||||
|
||||
# ---------- негативные сценарии ----------
|
||||
|
||||
def test_oversize(c):
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
big = b"\x89PNG\r\n\x1a\n" + b"\x00" * (10_485_761)
|
||||
status, body, _h = _upload(c, alice, chat, big)
|
||||
check(status == 413, "oversize upload must be 413, got %s" % status)
|
||||
|
||||
|
||||
def test_corrupted_image(c):
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
bad = b"\x89PNG\r\n\x1a\n" + b"not-a-real-png" * 100
|
||||
status, body, _h = _upload(c, alice, chat, bad)
|
||||
check(status == 415, "corrupted PNG must be 415, got %s" % status)
|
||||
|
||||
|
||||
def test_mime_spoof(c):
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
status, body, _h = _upload(c, alice, chat, b"hello, not an image" * 10, ctype="image/png")
|
||||
check(status == 415, "spoofed MIME must be 415, got %s" % status)
|
||||
|
||||
|
||||
def test_bad_filename(c):
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
data = SAMPLE.read_bytes()
|
||||
for bad in ("../evil.png", "a/b.png", "a\\b.png", "a\x00b.png", "a\nb.png", " "):
|
||||
status, body, _h = _upload(c, alice, chat, data, filename=bad)
|
||||
check(status == 400, "bad filename %r must be 400, got %s" % (bad, status))
|
||||
|
||||
|
||||
# ---------- изоляция доступа ----------
|
||||
|
||||
def test_foreign_attachment_and_cross_chat(c):
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
chat2 = c.call("POST", "/api/v1/chats", 201, actor=alice,
|
||||
body={"title": "Второй", "member_ids": [alice["id"], eve["id"]]},
|
||||
schema="Chat")["json"]
|
||||
data = SAMPLE.read_bytes()
|
||||
status, att, _h = _upload(c, alice, chat2, data)
|
||||
check(status == 201, "upload to chat2 must be 201, got %s" % status)
|
||||
att_id = att["id"]
|
||||
|
||||
c.call("GET", "/api/v1/attachments/" + att_id, 404, actor=bob)
|
||||
c.call("GET", "/api/v1/attachments/" + att_id + "/content", 404, actor=bob)
|
||||
|
||||
c.call(
|
||||
"POST", "/api/v1/chats/" + chat["id"] + "/messages",
|
||||
404, actor=bob,
|
||||
body={"text": "", "attachment_ids": [att_id]},
|
||||
headers={"Idempotency-Key": uuid.uuid4().hex},
|
||||
)
|
||||
|
||||
|
||||
def test_attachment_belongs_to_chat(c):
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
other = c.call("POST", "/api/v1/chats", 201, actor=alice,
|
||||
body={"title": "Другой", "member_ids": [alice["id"], bob["id"]]},
|
||||
schema="Chat")["json"]
|
||||
data = SAMPLE.read_bytes()
|
||||
status, att, _h = _upload(c, alice, chat, data)
|
||||
check(status == 201, "upload to chat must be 201")
|
||||
c.call(
|
||||
"POST", "/api/v1/chats/" + other["id"] + "/messages",
|
||||
404, actor=alice,
|
||||
body={"text": "", "attachment_ids": [att["id"]]},
|
||||
headers={"Idempotency-Key": uuid.uuid4().hex},
|
||||
)
|
||||
|
||||
|
||||
# ---------- компенсация: S3 PUT успешен, INSERT в БД падает ----------
|
||||
|
||||
def _compose(action, service):
|
||||
return subprocess.run(
|
||||
["docker", "compose", "--env-file", ".env", action, service],
|
||||
capture_output=True, text=True, timeout=90,
|
||||
)
|
||||
|
||||
|
||||
def _wait_ready(c, timeout=90):
|
||||
deadline = time.monotonic() + timeout
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
c.call("GET", "/health/ready", 200)
|
||||
return
|
||||
except Failure:
|
||||
time.sleep(1)
|
||||
raise Failure("API не вернулся в ready за %d секунд" % timeout)
|
||||
|
||||
|
||||
def _count_bucket_objects() -> int:
|
||||
env = os.environ.copy()
|
||||
env_file = ROOT / ".env"
|
||||
if env_file.is_file():
|
||||
for line in env_file.read_text(encoding="utf-8").splitlines():
|
||||
line = line.strip()
|
||||
if not line or line.startswith("#") or "=" not in line:
|
||||
continue
|
||||
k, v = line.split("=", 1)
|
||||
env.setdefault(k.strip(), v.strip())
|
||||
|
||||
user = env.get("MINIO_ROOT_USER", "minioadmin")
|
||||
password = env.get("MINIO_ROOT_PASSWORD", "minioadmin")
|
||||
bucket = env.get("S3_BUCKET", "messenger-attachments")
|
||||
mc_host = "http://%s:%s@minio:9000" % (user, password)
|
||||
|
||||
# Entrypoint образа mc обычно сам mc; тогда подкоманду зовём без префикса "mc".
|
||||
ins = subprocess.run(
|
||||
["docker", "image", "inspect", MC_IMAGE, "--format", "{{json .Config.Entrypoint}}"],
|
||||
capture_output=True, text=True, timeout=10,
|
||||
)
|
||||
ep = (ins.stdout or "").strip()
|
||||
prefix = [] if (ep and ep != "null" and "mc" in ep) else ["mc"]
|
||||
|
||||
r = subprocess.run(
|
||||
["docker", "run", "--rm", "--network", COMPOSE_NETWORK,
|
||||
"-e", "MC_HOST_local=" + mc_host, MC_IMAGE]
|
||||
+ prefix
|
||||
+ ["ls", "--recursive", "local/" + bucket],
|
||||
capture_output=True, text=True, timeout=60,
|
||||
)
|
||||
if r.returncode != 0:
|
||||
# Диагностика при первом запуске — увидим, что именно не так.
|
||||
print(" mc stderr:", (r.stderr or "").strip()[:300])
|
||||
return -1
|
||||
return sum(1 for line in r.stdout.splitlines() if line.startswith("["))
|
||||
|
||||
|
||||
def test_compensation_on_db_failure(c):
|
||||
"""S3 PUT прошёл, INSERT в БД упал → объект удаляется из S3, ответ 503.
|
||||
|
||||
Сценарий: останавливаем PostgreSQL. API-реплика сначала делает PUT в S3
|
||||
(успешно), затем INSERT в attachments (падает: connection error).
|
||||
В except-ветке upload_attachment вызывается s3.delete_object —
|
||||
orphan не остаётся. Ответ — 503 unavailable.
|
||||
После восстановления PG сверяем количество объектов в bucket.
|
||||
"""
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
data = SAMPLE.read_bytes()
|
||||
|
||||
before = _count_bucket_objects()
|
||||
check(before >= 0, "не удалось посчитать объекты в bucket (mc)")
|
||||
|
||||
stopped = _compose("stop", "postgres")
|
||||
check(stopped.returncode == 0, "docker compose stop postgres failed")
|
||||
time.sleep(2)
|
||||
try:
|
||||
status, body, _h = _upload(c, alice, chat, data)
|
||||
check(status in (500, 503),
|
||||
"compensation expected 5xx, got %s (body=%r)" % (status, body))
|
||||
print(" upload при мёртвой БД вернул %s" % status)
|
||||
finally:
|
||||
started = _compose("start", "postgres")
|
||||
check(started.returncode == 0, "docker compose start postgres failed")
|
||||
_wait_ready(c, timeout=90)
|
||||
|
||||
after = _count_bucket_objects()
|
||||
check(after == before,
|
||||
"orphan-объект остался в bucket: before=%s after=%s" % (before, after))
|
||||
print(" компенсация: bucket не вырос (before=%s after=%s)" % (before, after))
|
||||
|
||||
|
||||
# ---------- параллельные загрузки с измерением RSS ----------
|
||||
|
||||
def test_parallel_uploads_memory(c):
|
||||
"""Уровень 4: ≥10 одновременных загрузок с измерением пика RSS."""
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
data = SAMPLE.read_bytes()
|
||||
barrier = threading.Barrier(10)
|
||||
errors = []
|
||||
|
||||
def one(_):
|
||||
local = Client(c.base, timeout=60)
|
||||
barrier.wait()
|
||||
try:
|
||||
status, att, _h = _upload(local, alice, chat, data)
|
||||
if status != 201:
|
||||
errors.append("status=%s" % status)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
errors.append(type(exc).__name__)
|
||||
|
||||
def rss():
|
||||
if not API_CONTAINER:
|
||||
return None
|
||||
try:
|
||||
out = subprocess.run(
|
||||
["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", API_CONTAINER],
|
||||
capture_output=True, text=True, timeout=10,
|
||||
)
|
||||
used = out.stdout.strip().split("/")[0].strip()
|
||||
if used.endswith("MiB"):
|
||||
return float(used[:-3])
|
||||
if used.endswith("GiB"):
|
||||
return float(used[:-3]) * 1024
|
||||
except Exception:
|
||||
return None
|
||||
return None
|
||||
|
||||
peak = {"value": 0.0}
|
||||
stop = threading.Event()
|
||||
|
||||
def sampler():
|
||||
while not stop.is_set():
|
||||
v = rss()
|
||||
if v and v > peak["value"]:
|
||||
peak["value"] = v
|
||||
time.sleep(0.2)
|
||||
|
||||
sampler_thread = threading.Thread(target=sampler, daemon=True)
|
||||
sampler_thread.start()
|
||||
|
||||
with ThreadPoolExecutor(max_workers=10) as pool:
|
||||
list(pool.map(one, range(10)))
|
||||
|
||||
stop.set()
|
||||
sampler_thread.join(timeout=2)
|
||||
|
||||
check(not errors, "parallel uploads errors: %s" % errors[:3])
|
||||
print(" 10 параллельных загрузок, пик RSS=%s MiB" % peak["value"])
|
||||
if peak["value"]:
|
||||
check(peak["value"] < 400, "peak RSS %s MiB слишком высок" % peak["value"])
|
||||
|
||||
|
||||
# ---------- main ----------
|
||||
|
||||
def main():
|
||||
args = arguments("Lab4 level 4 checks")
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
|
||||
print("=== oversize ===")
|
||||
test_oversize(c)
|
||||
print("PASS: oversize -> 413")
|
||||
|
||||
print("=== corrupted image ===")
|
||||
test_corrupted_image(c)
|
||||
print("PASS: corrupted -> 415")
|
||||
|
||||
print("=== spoofed MIME ===")
|
||||
test_mime_spoof(c)
|
||||
print("PASS: spoofed MIME -> 415")
|
||||
|
||||
print("=== bad filename ===")
|
||||
test_bad_filename(c)
|
||||
print("PASS: bad filename -> 400")
|
||||
|
||||
print("=== foreign attachment / cross-chat ===")
|
||||
test_foreign_attachment_and_cross_chat(c)
|
||||
print("PASS: foreign -> 404, cross-chat -> 404")
|
||||
|
||||
print("=== attachment belongs to chat ===")
|
||||
test_attachment_belongs_to_chat(c)
|
||||
print("PASS: attachment from another chat -> 404")
|
||||
|
||||
print("=== compensation on DB failure ===")
|
||||
test_compensation_on_db_failure(c)
|
||||
print("PASS: компенсация orphan-объектов при отказе БД")
|
||||
|
||||
print("=== parallel uploads memory ===")
|
||||
test_parallel_uploads_memory(c)
|
||||
print("PASS: 10 параллельных загрузок в пределах лимита памяти")
|
||||
|
||||
print("PASS: all lab4 level-4 checks passed")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
Reference in New Issue
Block a user