feat: база из лабораторной 3 перенесена в лабу 4
This commit is contained in:
@@ -11,10 +11,3 @@ SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
S3_ENDPOINT=http://s3:9000
|
||||
S3_REGION=us-east-1
|
||||
S3_BUCKET=messenger-attachments
|
||||
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
|
||||
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
|
||||
MAX_UPLOAD_BYTES=10485760
|
||||
MAX_IMAGE_PIXELS=40000000
|
||||
|
||||
+1
-2
@@ -28,5 +28,4 @@ coverage/
|
||||
.DS_Store
|
||||
.idea/
|
||||
.vscode/
|
||||
# Keep small, sanitized evidence summaries in evidence/ under version control.
|
||||
# Inspect git diff --cached: ignore rules are not a secret scanner.
|
||||
|
||||
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
FROM golang:1.22-alpine AS builder
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY go.mod go.sum ./
|
||||
RUN go mod download
|
||||
|
||||
COPY . .
|
||||
|
||||
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -o /app/server ./cmd/server
|
||||
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -o /app/migrate ./cmd/migrate
|
||||
|
||||
FROM alpine:3.19
|
||||
|
||||
RUN apk add --no-cache ca-certificates wget
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY --from=builder /app/server .
|
||||
COPY --from=builder /app/migrate .
|
||||
COPY --from=builder /app/internal/migrate/sql ./internal/migrate/sql
|
||||
|
||||
RUN adduser -D -H -u 10001 appuser
|
||||
USER appuser
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
ENTRYPOINT ["./server"]
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
# Памятка преподавателю — лабораторная 4
|
||||
# Памятка преподавателю — лабораторная 3
|
||||
|
||||
## Что подготовлено
|
||||
|
||||
|
||||
@@ -1,30 +1,35 @@
|
||||
PYTHON ?= python3
|
||||
BASE_URL ?= http://localhost:8080
|
||||
CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
COMPOSE ?= docker compose
|
||||
|
||||
.PHONY: help check validate test load test-persistence test-failover
|
||||
.PHONY: up down migrate restart test logs stop-one restart-one clean check
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
up:
|
||||
$(COMPOSE) up -d --build
|
||||
|
||||
down:
|
||||
$(COMPOSE) down
|
||||
|
||||
migrate:
|
||||
$(COMPOSE) exec api1 ./migrate up
|
||||
|
||||
restart:
|
||||
$(COMPOSE) restart
|
||||
|
||||
test:
|
||||
$(PYTHON) tests/client.py
|
||||
$(PYTHON) tests/load.py
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
|
||||
validate:
|
||||
$(PYTHON) scripts/validate_openapi.py
|
||||
logs:
|
||||
$(COMPOSE) logs -f
|
||||
|
||||
test:
|
||||
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
stop-one:
|
||||
./scripts/stop-one.sh api1
|
||||
|
||||
load:
|
||||
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
restart-one:
|
||||
./scripts/restart-one.sh api1
|
||||
|
||||
test-persistence:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
test-failover:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
clean: down
|
||||
$(COMPOSE) down -v
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Лабораторная 4. S3-хранилище и вложения
|
||||
# Лабораторная 3. Балансировка и отказ API-реплики
|
||||
|
||||
Разделить метаданные и бинарное содержимое, добавить изображения в сообщения и сохранить доступ к ним при переключении API-реплики.
|
||||
Запустить несколько взаимозаменяемых экземпляров API за единой точкой входа и сохранить корректность при остановке одного из них.
|
||||
|
||||
Это **skeleton**, а не готовый сервер. Здесь есть задание, контракт и публичные проверки. Реализацию приложения, Dockerfile и требуемую инфраструктуру пишет студент. Язык и framework свободные; UI не обязателен.
|
||||
|
||||
@@ -8,41 +8,42 @@
|
||||
|
||||
## Откуда начинаем
|
||||
|
||||
Перенесите минимум lab3. Дополняются поля сообщения и endpoint вложений; прежние текстовые POST остаются валидными.
|
||||
Нужен минимум lab2: PostgreSQL, общие действующие сессии, миграции. Добавляются X-Instance-Id и обязательный Idempotency-Key при отправке сообщения.
|
||||
|
||||
**Архитектура:** Клиент → LB → API × 2+ → PostgreSQL (метаданные) + приватное S3-хранилище (байты).
|
||||
**Архитектура:** Клиент → LB → API × 2+ → общие PostgreSQL и хранилище сессий. Compose или Swarm — на выбор.
|
||||
|
||||
## Что сделать
|
||||
|
||||
1. Выберите один S3-совместимый сервер: MinIO, SeaweedFS или RustFS. Закрепите проверенную версию образа и опишите создание приватного bucket.
|
||||
2. Спроектируйте Attachment и связь с чатом/сообщением. S3 object key назначает сервер, filename используется только для отображения.
|
||||
3. Реализуйте синхронный binary upload PNG/JPEG с ограничениями, сохранение метаданных и авторизованный download через API.
|
||||
4. Включите S3 и persistent volumes в общий Compose/Swarm. Проверьте, что другая API-реплика скачивает файл после остановки загрузившей.
|
||||
5. Проверьте недоступность S3, чужой чат и restart всего стенда.
|
||||
1. Выберите Compose + Nginx/HAProxy/Traefik либо Docker Swarm. Для выбранного варианта дайте одну последовательность запуска.
|
||||
2. Уберите локальные сессии/другие данные, от которых зависит корректность, из API. Миграции выполняйте отдельно и согласованно, а не гонкой всех реплик.
|
||||
3. Настройте балансировщик, проверки готовности, DNS/обновление backend-адресов и graceful shutdown. Не закрепляйте клиента sticky session как способ исправить раздельное состояние.
|
||||
4. Реализуйте общую идемпотентность отправки сообщения. Проверьте одинаковый ключ одновременно через разные реплики.
|
||||
5. Подготовьте явный action script, останавливающий одну выбранную API-реплику, и продемонстрируйте чтение/запись во время отказа.
|
||||
|
||||
## Оценка «3»: работающий минимум
|
||||
|
||||
- Все обязательные возможности lab3 сохранены. S3-сервер находится в общем стенде; метаданные вложений живут в PostgreSQL, байты — в приватном bucket, не в БД или локальном каталоге API.
|
||||
- POST вложения возвращает 201 ready после сохранения; оригинал скачивается побайтно. Message с attachment_ids читается участниками чата. Публичный smoke проверяет checksum и отсутствие доступа у постороннего.
|
||||
- Принимаются реальные PNG/JPEG ≤10 MiB и ≤40 млн пикселей; MIME проверяется по содержимому, опасные filename отклоняются, лимиты применяются до неограниченного чтения/декодирования.
|
||||
- Upload → остановка обслужившей API-реплики → download через другую возвращает тот же файл. Restart с сохранением volumes сохраняет метаданные и оригинал.
|
||||
- Весь стенд описан в compose.yaml или stack.yaml, запускается документированной командой. Не менее двух API-реплик, одна публичная точка входа, одна общая БД и общее хранилище сессий.
|
||||
- Разные запросы одного пользователя обслуживаются разными репликами без повторного входа. Это видно по X-Instance-Id. Доступ через LB — основной проверяемый маршрут.
|
||||
- Можно остановить любую одну API-реплику при работающей другой: не позднее 10 секунд продолжаются новые чтения/записи, подтверждённые сообщения доступны. Краткие ошибки/оборванные запросы во время обнаружения отказа измеряются и допустимы.
|
||||
- Повтор POST сообщения с тем же Idempotency-Key не создаёт дубль, включая конкурентный повтор и переключение реплики. Неподтверждённую запись клиент может безопасно повторить с тем же ключом.
|
||||
- make test, persistence и failover-сценарий проходят; для failover проверяется наличие ≥2 наблюдаемых реплик. Для Swarm сборка образа и его доступность узлам описаны отдельно.
|
||||
|
||||
## Оценка «4»: уровень стажёра/джуна
|
||||
|
||||
Весь уровень 3 **и все** пункты ниже:
|
||||
|
||||
- Тесты покрывают слишком большой файл, повреждённое изображение, подмену MIME, чужое attachment_id и привязку файла другого чата. Пользовательская ошибка не превращается в 500.
|
||||
- Прерывание загрузки и отказ между записью S3/БД не оставляют вечных неучтённых объектов: есть документированный механизм компенсации/сверки/очистки с безопасным grace period.
|
||||
- Лимиты/таймауты и потоковая обработка не позволяют одной загрузке занять неограниченную RAM. Проведён эксперимент ≥10 одновременных загрузок с измерением пика памяти.
|
||||
- Bucket bootstrap идемпотентен; API использует отдельные S3 credentials с ограниченными правами. Административная консоль не открыта в общей сети. Есть проверка private bucket вне API.
|
||||
- Health/readiness, timeouts и прекращение приёма при SIGTERM настроены согласованно; LB исключает недоступный backend. Укажите период проверок и максимальное время обнаружения отказа.
|
||||
- Последовательно остановите каждую API-реплику (восстанавливая предыдущую); соберите RPS, ошибки и время восстановления. Общая идемпотентность проверяется параллельными запросами с одним ключом.
|
||||
- Контейнеры имеют CPU/RAM-лимиты, API не публикуют порты наружу в обход LB; секреты и хранилища общие только там, где нужно. Нет container_name, мешающего масштабированию одного Compose-service.
|
||||
- Rolling update или эквивалентная поочерёдная замена проверена под нагрузкой. Миграции запускаются однократно и совместимы с работающей версией либо ограничение честно описано.
|
||||
|
||||
## Оценка «5»: исследование и доказанный результат
|
||||
|
||||
Весь уровень 4 **и один законченный трек на выбор**. Приведите гипотезу, повторяемую методику, результаты и ограничения.
|
||||
|
||||
**Трек 1. Прямой upload.** Добавьте отдельный безопасный presigned-upload flow: короткая подпись, уникальный ключ, проверка принадлежности, размера/checksum при complete, обработка незавершённой загрузки. Сохраните обязательный proxy endpoint. Сравните трафик и RAM API при ≥2 размерах файлов, покажите негативные сценарии.
|
||||
**Трек 1. Цена масштабирования.** При фиксированном суммарном CPU/RAM сравните 1/2/4 API-реплики на одном профиле нагрузки; затем проведите серию с ростом ресурсов. Найдите saturation point БД/LB/пула и покажите, почему рост реплик перестаёт помогать. Дайте исходные данные, графики и одно подтверждённое улучшение.
|
||||
|
||||
**Трек 2. Согласованность двух хранилищ.** Разработайте повторяемый reconciler для orphan/missing объектов и метаданных. Внедрите ошибки на обеих сторонах, покажите обнаружение и безопасное исправление с dry-run/повторным запуском. Докажите, что свежие и используемые вложения не удаляются; измерьте стоимость обхода.
|
||||
**Трек 2. Отказ узла.** Расширьте стенд до нескольких узлов, покажите перенос API при потере узла и разберите оставшиеся SPOF (LB, DB, storage). Для заявленной защищённой зависимости покажите реальный failover и сохранность данных. Если DB не реплицирована, не заявляйте выживание её узла.
|
||||
|
||||
## Как начать и проверить
|
||||
|
||||
@@ -78,28 +79,26 @@ Smoke не выставляет оценку автоматически. Про
|
||||
|
||||
## Сценарий защиты
|
||||
|
||||
1. Загрузить fixture, отправить message с attachment_ids, скачать как второй участник и сравнить SHA-256.
|
||||
2. С третьим пользователем получить 404 для метаданных и bytes; direct unauthenticated S3 GET не отдаёт объект.
|
||||
3. Выполнить persistence и failover: общий тест начиная с lab4 сохраняет и повторно читает оригинал через API.
|
||||
4. Показать, что на API нет обязательного локального файла оригинала. Для 4/5 — отказы и эксперименты.
|
||||
1. Запустить стенд и показать ≥2 разных X-Instance-Id через LB с одной сессией.
|
||||
2. Запустить make test-failover ACTION_SCRIPT=scripts/stop-one.sh. Скрипт теста выполняет запросы во время action, учитывает ошибки и повторяет сообщения с исходным ключом.
|
||||
3. Показать, какой контейнер действительно остановлен; заголовок сам по себе не доказательство разных процессов. Повторить для второй реплики после восстановления первой.
|
||||
4. Проверить restart всего стенда с сохранением volumes и неизменным токеном. Для 4/5 — соответствующие эксперименты.
|
||||
|
||||
## Что должно быть в PR
|
||||
|
||||
Дополненный стенд, настройка bucket/политики, миграции Attachment, тесты файлов, описание согласованности БД/S3 и результаты.
|
||||
compose.yaml или stack.yaml, конфигурация LB, scripts/restart.sh, scripts/stop-one.sh, Dockerfile, миграции, результаты отказов.
|
||||
|
||||
Заполните `REPORT.md` и [шаблон PR](.github/pull_request_template.md), укажите целевую оценку/трек. Не меняйте обязательный контракт и публичные tests ради зелёного результата. Сохраняйте возможности предыдущих лабораторных в пределах [объявленных переходов](COURSE.md).
|
||||
|
||||
## Вопросы на защите
|
||||
|
||||
- Почему файл в Docker volume одной API-реплики не равен объектному хранилищу?
|
||||
- Когда можно честно вернуть 201?
|
||||
- Что произойдёт, если S3 PUT прошёл, а COMMIT в PostgreSQL — нет?
|
||||
- Почему случайный object key и приватный bucket не заменяют ACL приложения?
|
||||
- Чем отказ процесса отличается от отказа узла?
|
||||
- Почему depends_on/healthcheck сами по себе не являются балансировщиком?
|
||||
- Какие POST можно повторять после timeout и что защищает Idempotency-Key?
|
||||
- Что сломается при увеличении числа API, если сессии находятся в локальной памяти?
|
||||
|
||||
## Первичные материалы
|
||||
|
||||
- [S3 object uploads](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)
|
||||
- [Presigned URLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html)
|
||||
- [MinIO](https://github.com/minio/minio)
|
||||
- [SeaweedFS](https://github.com/seaweedfs/seaweedfs)
|
||||
- [RustFS](https://docs.rustfs.com/)
|
||||
- [Compose services](https://docs.docker.com/reference/compose-file/services/)
|
||||
- [Swarm routing mesh](https://docs.docker.com/engine/swarm/ingress/)
|
||||
- [Swarm services](https://docs.docker.com/engine/swarm/services/)
|
||||
|
||||
@@ -1,37 +1,208 @@
|
||||
# Отчёт — лабораторная 4
|
||||
# Отчёт — лабораторная 3
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор / группа: Фараджев Р.Э / БПИ2303
|
||||
- Целевая оценка(3/4/5): 3
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
**Prerequisites:**
|
||||
- Docker Desktop для Windows (версия 4.25+)
|
||||
- Go 1.22+ (локально не требуется, только в Docker)
|
||||
- Python 3.10+ (для тестов)
|
||||
- PowerShell 5.1+ или Git Bash
|
||||
|
||||
**Команды запуска:**
|
||||
|
||||
```powershell
|
||||
# 1. Клонирование и переход в директорию
|
||||
git clone <repository-url>
|
||||
cd mtusi2026lab3
|
||||
|
||||
# 2. Создание .env файла (опционально, конфигурация в docker-compose.yaml)
|
||||
cp .env.example .env
|
||||
|
||||
# 3. Очистка старых контейнеров (если есть)
|
||||
docker compose down -v
|
||||
|
||||
# 4. Сборка и запуск
|
||||
docker compose up -d --build
|
||||
|
||||
# 5. Ожидание готовности (healthcheck ~15-20 секунд)
|
||||
Start-Sleep -Seconds 20
|
||||
docker compose ps
|
||||
# Все контейнеры должны быть в статусе "healthy"
|
||||
|
||||
# 6. Применение миграций (ТОЛЬКО НА ОДНОЙ РЕПЛИКЕ)
|
||||
docker compose exec api1 ./migrate up
|
||||
|
||||
# 7. Проверка работоспособности
|
||||
curl http://localhost:8080/health
|
||||
# Ожидаемый ответ: {"instance":"api1","status":"ok"} или api2
|
||||
|
||||
# 8. Запуск тестов
|
||||
python tests/client.py
|
||||
python tests/load.py
|
||||
|
||||
# 9. Безопасная остановка
|
||||
docker compose down
|
||||
|
||||
# 10. Удаление учебных данных (полная очистка)
|
||||
docker compose down -v
|
||||
```
|
||||
|
||||
**Необходимые действия оператора:**
|
||||
- Миграции запускаются вручную один раз после первого поднятия
|
||||
- Healthcheck автоматически проверяет готовность сервисов (15-20 сек)
|
||||
- Для повторного запуска с чистыми данными: `docker compose down -v`
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
**Схема компонентов:**
|
||||
|
||||
```
|
||||
Клиент (curl/Python тесты)
|
||||
↓
|
||||
HAProxy:8080 (балансировщик, round-robin)
|
||||
↓
|
||||
─────┴─────┐
|
||||
↓ ↓
|
||||
api1:8080 api2:8080 (Go HTTP серверы)
|
||||
↓ ↓
|
||||
└─────┬─────┘
|
||||
↓
|
||||
PostgreSQL:5432 (общая БД)
|
||||
- users (пользователи)
|
||||
- sessions (сессии)
|
||||
- messages (сообщения)
|
||||
- idempotency_keys (идемпотентность)
|
||||
```
|
||||
|
||||
**Источник истины:** PostgreSQL — единственное хранилище состояния (сессии, сообщения, ключи идемпотентности).
|
||||
|
||||
**Транзакционные границы:**
|
||||
- Каждая HTTP обработка — отдельная транзакция
|
||||
- Идемпотентность: `BEGIN` → `SELECT FOR UPDATE` → `INSERT` → `COMMIT`
|
||||
- Блокировка на уровне БД предотвращает дубли при конкурентных запросах
|
||||
|
||||
**Ограничения:**
|
||||
- PostgreSQL и HAProxy — единые точки отказа (не реплицированы)
|
||||
- Сессии хранятся 24 часа (sessionTTL)
|
||||
- Максимальный размер запроса: 1MB
|
||||
- Graceful shutdown: 15 секунд
|
||||
|
||||
**Что перенесено из lab2:**
|
||||
- Модели данных (users, sessions, messages)
|
||||
- Хэширование паролей (bcrypt)
|
||||
- Миграции SQL
|
||||
|
||||
**Что изменено/добавлено:**
|
||||
- Docker Compose оркестрация
|
||||
- HAProxy балансировщик
|
||||
- Две API-реплики (api1, api2)
|
||||
- X-Instance-Id заголовок
|
||||
- Идемпотентность через idempotency_keys таблицу
|
||||
- Healthcheck endpoints
|
||||
- Graceful shutdown
|
||||
|
||||
**Соответствие .env.example:**
|
||||
- `DATABASE_URL` → используется в docker-compose.yaml (postgres://app:app@postgres:5432/app)
|
||||
- `APP_INSTANCE_ID` → передаётся как env в контейнеры (api1/api2)
|
||||
- `APP_PORT` → 8080 (внутренний порт контейнера)
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| **Публичный smoke** | `make test` или `python tests/client.py` | `All API checks passed` (12 PASS) | tests/client.py |
|
||||
| **2 API-реплики** | `docker compose ps` | api1 и api2 в статусе Up (healthy) | docker-compose.yaml |
|
||||
| **Одна точка входа** | `curl http://localhost:8080/health` | JSON с instance field | infra/haproxy.cfg |
|
||||
| **Балансировка без sticky** | 4 запроса подряд к /health | Чередование api1/api2 | tests/load.py |
|
||||
| **Общая БД и сессии** | Логин → GET /api/messages | Сессия работает на обеих репликах | cmd/server/main.go |
|
||||
| **X-Instance-Id** | `curl -sI http://localhost:8080/health \| grep X-Instance-Id` | Заголовок присутствует | cmd/server/main.go |
|
||||
| **Отказоустойчивость** | `docker compose stop api1` + запросы | В течение 10с запросы идут через api2 | tests/load.py |
|
||||
| **Идемпотентность** | POST с Idempotency-Key дважды | Первый 201, второй 200, тот же id | cmd/server/main.go |
|
||||
| **Миграции отдельно** | `docker compose exec api1 ./migrate up` | `migrate up: done` | cmd/migrate/main.go |
|
||||
| **Graceful shutdown** | `docker compose stop api1` | В логах: "shutting down" | cmd/server/main.go |
|
||||
| **Failover сценарий** | `python tests/load.py` | `Failover scenario passed` | tests/load.py |
|
||||
| **Persistence** | `python tests/load.py` | `no duplicate messages in history` | tests/load.py |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
**Гипотеза:** Система выдерживает остановку одной API-реплики без потери данных и с минимальным временем восстановления.
|
||||
|
||||
**Hardware/лимиты:**
|
||||
- CPU: AMD Ryzen 7 4000 series (8 cores)
|
||||
- RAM: 16 GB
|
||||
- Docker limits: api1/api2 — 256MB RAM, 1.0 CPU; postgres — 512MB RAM
|
||||
- OS: Windows 11 + Docker Desktop
|
||||
|
||||
**Профиль нагрузки:**
|
||||
- Объём данных: 1 пользователь, ~10 сообщений
|
||||
- Concurrency: 20 параллельных запросов (threading)
|
||||
- Длительность: ~15 секунд (включая failover)
|
||||
- Прогрев: 5 запросов перед тестом
|
||||
|
||||
**Результаты:**
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| `docker compose stop api1` | HAProxy перенаправляет на api2 | `requests recovered within 10s (5.24s, 3 transient errors)` | 5.24 сек / 0 потерянных сообщений |
|
||||
| `docker compose start api1` | api1 возвращается в ротацию | `api1 is back in rotation: ['api1', 'api2']` | ~10 сек (healthcheck) / нет |
|
||||
| POST с тем же Idempotency-Key | Не создаётся дубль | `replay returns the same id (1 vs 1)` | N/A / нет дублей |
|
||||
| Запросы во время failover | Кратковременные ошибки 502/503 | `3 transient errors` за 5.24 сек | N/A / допустимы |
|
||||
|
||||
**Raw summary (tests/load.py):**
|
||||
```
|
||||
PASS: message written before failover (got 201)
|
||||
PASS: requests reached at least two replicas: ['api1', 'api2']
|
||||
PASS: docker compose stop api1 succeeded
|
||||
PASS: reads recovered within 10s (5.24s, 3 transient errors)
|
||||
PASS: requests still served while api1 is down
|
||||
PASS: api1 left rotation, served by: ['api2']
|
||||
PASS: write works while api1 is down (got 201)
|
||||
PASS: docker compose start api1 succeeded
|
||||
PASS: api1 is back in rotation: ['api1', 'api2']
|
||||
PASS: history readable after failover (got 200)
|
||||
PASS: message written before failover survived
|
||||
PASS: no duplicate messages in history
|
||||
|
||||
Failover scenario passed
|
||||
```
|
||||
|
||||
**Ограничения измерения:**
|
||||
- Тесты запускаются локально (сетевая задержка минимальна)
|
||||
- Не измеряется p95/p99 (мало запросов)
|
||||
- Docker Desktop добавляет оверхед (~10-20%)
|
||||
- Не тестируется отказ PostgreSQL или HAProxy
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
**Какие отказы выдерживаются:**
|
||||
- ✅ Остановка одной API-реплики (api1 или api2)
|
||||
- ✅ Конкурентные запросы с одинаковым Idempotency-Key (нет дублей)
|
||||
- ✅ Graceful shutdown (15s timeout)
|
||||
|
||||
**Какие отказы НЕ выдерживаются:**
|
||||
- ❌ Отказ PostgreSQL (единая точка отказа)
|
||||
- ❌ Отказ HAProxy (единая точка отказа)
|
||||
- ❌ Потеря данных при `docker compose down -v`
|
||||
|
||||
**Что не реализовано:**
|
||||
- Репликация PostgreSQL (master-slave)
|
||||
- Healthcheck для HAProxy (external)
|
||||
- Rolling update (level 4)
|
||||
- Нагрузочное тестирование (ab, wrk)
|
||||
- Metrics (Prometheus) и логирование (ELK)
|
||||
|
||||
**Учебное упрощение:**
|
||||
- Сессии не инвалидизируются при logout на всех репликах (только в БД)
|
||||
- Нет rate limiting
|
||||
- Нет HTTPS (только HTTP)
|
||||
- Пароль тестового пользователя захардкожен в миграции
|
||||
|
||||
**Следующие шаги (если нужно улучшить):**
|
||||
1. Добавить репликацию PostgreSQL (Patroni или pgpool)
|
||||
2. Добавить keepalived для HAProxy (VIP)
|
||||
3. Реализовать circuit breaker между репликами
|
||||
4. Добавить Prometheus metrics (request_count, error_rate, latency)
|
||||
5. Настроить централизованное логирование (Loki + Promtail)
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"os"
|
||||
|
||||
_ "github.com/lib/pq"
|
||||
)
|
||||
|
||||
const (
|
||||
upFile = "internal/migrate/sql/001_init.sql"
|
||||
downSQL = `DROP TABLE IF EXISTS idempotency_keys;
|
||||
DROP TABLE IF EXISTS messages;
|
||||
DROP TABLE IF EXISTS sessions;
|
||||
DROP TABLE IF EXISTS users;`
|
||||
)
|
||||
|
||||
func main() {
|
||||
if len(os.Args) < 2 {
|
||||
fail("usage: migrate [up|down]")
|
||||
}
|
||||
|
||||
databaseURL := os.Getenv("DATABASE_URL")
|
||||
if databaseURL == "" {
|
||||
fail("DATABASE_URL is required")
|
||||
}
|
||||
|
||||
db, err := sql.Open("postgres", databaseURL)
|
||||
if err != nil {
|
||||
fail("open database: " + err.Error())
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
if err := db.Ping(); err != nil {
|
||||
fail("ping database: " + err.Error())
|
||||
}
|
||||
|
||||
switch os.Args[1] {
|
||||
case "up":
|
||||
if err := migrateUp(db); err != nil {
|
||||
fail("migrate up: " + err.Error())
|
||||
}
|
||||
fmt.Println("migrate up: done")
|
||||
case "down":
|
||||
if _, err := db.Exec(downSQL); err != nil {
|
||||
fail("migrate down: " + err.Error())
|
||||
}
|
||||
fmt.Println("migrate down: done")
|
||||
default:
|
||||
fail("unknown command: " + os.Args[1])
|
||||
}
|
||||
}
|
||||
|
||||
func migrateUp(db *sql.DB) error {
|
||||
script, err := os.ReadFile(upFile)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = db.Exec(string(script))
|
||||
return err
|
||||
}
|
||||
|
||||
func fail(message string) {
|
||||
fmt.Fprintln(os.Stderr, message)
|
||||
os.Exit(1)
|
||||
}
|
||||
@@ -0,0 +1,372 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
_ "github.com/lib/pq"
|
||||
|
||||
"mtusi2026lab3/internal/config"
|
||||
"mtusi2026lab3/internal/ident"
|
||||
"mtusi2026lab3/internal/password"
|
||||
)
|
||||
|
||||
const (
|
||||
sessionTTL = 24 * time.Hour
|
||||
shutdownTimeout = 15 * time.Second
|
||||
readHeaderTimeout = 5 * time.Second
|
||||
idleTimeout = 60 * time.Second
|
||||
instanceHeader = "X-Instance-Id"
|
||||
idempotencyHeader = "Idempotency-Key"
|
||||
maxIdempotencyKey = 128
|
||||
)
|
||||
|
||||
type server struct {
|
||||
db *sql.DB
|
||||
instance string
|
||||
}
|
||||
|
||||
type credentials struct {
|
||||
Login string `json:"login"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
|
||||
type newMessage struct {
|
||||
Recipient string `json:"recipient"`
|
||||
Body string `json:"body"`
|
||||
}
|
||||
|
||||
type message struct {
|
||||
ID int64 `json:"id"`
|
||||
SenderID int64 `json:"sender_id"`
|
||||
Recipient string `json:"recipient"`
|
||||
Body string `json:"body"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
}
|
||||
|
||||
type session struct {
|
||||
UserID int64
|
||||
Login string
|
||||
}
|
||||
|
||||
var errNoSession = errors.New("no valid session")
|
||||
|
||||
func main() {
|
||||
cfg := config.Load()
|
||||
|
||||
db, err := sql.Open("postgres", cfg.DatabaseURL)
|
||||
if err != nil {
|
||||
log.Fatalf("open database: %v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
db.SetMaxOpenConns(20)
|
||||
db.SetMaxIdleConns(10)
|
||||
db.SetConnMaxLifetime(5 * time.Minute)
|
||||
|
||||
if err := db.Ping(); err != nil {
|
||||
log.Fatalf("ping database: %v", err)
|
||||
}
|
||||
|
||||
srv := &server{db: db, instance: cfg.InstanceID}
|
||||
|
||||
httpServer := &http.Server{
|
||||
Addr: ":" + cfg.Port,
|
||||
Handler: srv.routes(),
|
||||
ReadHeaderTimeout: readHeaderTimeout,
|
||||
IdleTimeout: idleTimeout,
|
||||
}
|
||||
|
||||
go func() {
|
||||
log.Printf("instance %s listening on %s", cfg.InstanceID, httpServer.Addr)
|
||||
if err := httpServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
|
||||
log.Fatalf("listen: %v", err)
|
||||
}
|
||||
}()
|
||||
|
||||
stop := make(chan os.Signal, 1)
|
||||
signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT)
|
||||
<-stop
|
||||
|
||||
log.Printf("instance %s shutting down", cfg.InstanceID)
|
||||
ctx, cancel := context.WithTimeout(context.Background(), shutdownTimeout)
|
||||
defer cancel()
|
||||
if err := httpServer.Shutdown(ctx); err != nil {
|
||||
log.Printf("shutdown: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *server) routes() http.Handler {
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("GET /health", s.handleHealth)
|
||||
mux.HandleFunc("POST /api/auth/login", s.handleLogin)
|
||||
mux.HandleFunc("POST /api/auth/logout", s.handleLogout)
|
||||
mux.HandleFunc("GET /api/messages", s.handleListMessages)
|
||||
mux.HandleFunc("POST /api/messages", s.handleCreateMessage)
|
||||
return s.addInstanceID(mux)
|
||||
}
|
||||
|
||||
func (s *server) addInstanceID(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set(instanceHeader, s.instance)
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *server) handleHealth(w http.ResponseWriter, r *http.Request) {
|
||||
writeJSON(w, http.StatusOK, map[string]string{
|
||||
"status": "ok",
|
||||
"instance": s.instance,
|
||||
})
|
||||
}
|
||||
|
||||
func (s *server) handleLogin(w http.ResponseWriter, r *http.Request) {
|
||||
var in credentials
|
||||
if err := decodeJSON(w, r, &in); err != nil {
|
||||
writeError(w, http.StatusBadRequest, "invalid_request", "malformed json body")
|
||||
return
|
||||
}
|
||||
|
||||
in.Login = strings.TrimSpace(in.Login)
|
||||
if in.Login == "" || in.Password == "" {
|
||||
writeError(w, http.StatusBadRequest, "invalid_request", "login and password are required")
|
||||
return
|
||||
}
|
||||
|
||||
var (
|
||||
userID int64
|
||||
hash string
|
||||
)
|
||||
err := s.db.QueryRowContext(r.Context(),
|
||||
`SELECT id, password_hash FROM users WHERE login = $1`, in.Login).Scan(&userID, &hash)
|
||||
if errors.Is(err, sql.ErrNoRows) || (err == nil && !password.Check(in.Password, hash)) {
|
||||
writeError(w, http.StatusUnauthorized, "unauthorized", "invalid credentials")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "login failed")
|
||||
return
|
||||
}
|
||||
|
||||
token := ident.GenerateToken()
|
||||
expiresAt := time.Now().Add(sessionTTL).UTC()
|
||||
if _, err := s.db.ExecContext(r.Context(),
|
||||
`INSERT INTO sessions (user_id, token, expires_at) VALUES ($1, $2, $3)`,
|
||||
userID, token, expiresAt); err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "session create failed")
|
||||
return
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, map[string]any{
|
||||
"token": token,
|
||||
"token_type": "Bearer",
|
||||
"expires_at": expiresAt,
|
||||
})
|
||||
}
|
||||
|
||||
func (s *server) handleLogout(w http.ResponseWriter, r *http.Request) {
|
||||
token, ok := bearerToken(r)
|
||||
if !ok {
|
||||
writeError(w, http.StatusUnauthorized, "unauthorized", "bearer token required")
|
||||
return
|
||||
}
|
||||
if _, err := s.authenticate(r); err != nil {
|
||||
writeError(w, http.StatusUnauthorized, "unauthorized", "invalid or expired session")
|
||||
return
|
||||
}
|
||||
if _, err := s.db.ExecContext(r.Context(), `DELETE FROM sessions WHERE token = $1`, token); err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "logout failed")
|
||||
return
|
||||
}
|
||||
w.WriteHeader(http.StatusOK)
|
||||
}
|
||||
|
||||
func (s *server) handleListMessages(w http.ResponseWriter, r *http.Request) {
|
||||
sess, err := s.authenticate(r)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusUnauthorized, "unauthorized", "invalid or expired session")
|
||||
return
|
||||
}
|
||||
|
||||
rows, err := s.db.QueryContext(r.Context(),
|
||||
`SELECT id, sender_id, recipient, body, created_at
|
||||
FROM messages WHERE recipient = $1 ORDER BY id`, sess.Login)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "query failed")
|
||||
return
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
items := make([]message, 0)
|
||||
for rows.Next() {
|
||||
var m message
|
||||
if err := rows.Scan(&m.ID, &m.SenderID, &m.Recipient, &m.Body, &m.CreatedAt); err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "scan failed")
|
||||
return
|
||||
}
|
||||
items = append(items, m)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "read failed")
|
||||
return
|
||||
}
|
||||
|
||||
writeJSON(w, http.StatusOK, items)
|
||||
}
|
||||
|
||||
func (s *server) handleCreateMessage(w http.ResponseWriter, r *http.Request) {
|
||||
sess, err := s.authenticate(r)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusUnauthorized, "unauthorized", "invalid or expired session")
|
||||
return
|
||||
}
|
||||
|
||||
key := strings.TrimSpace(r.Header.Get(idempotencyHeader))
|
||||
if key == "" || len(key) > maxIdempotencyKey {
|
||||
writeError(w, http.StatusBadRequest, "invalid_request", "Idempotency-Key header is required")
|
||||
return
|
||||
}
|
||||
|
||||
var in newMessage
|
||||
if err := decodeJSON(w, r, &in); err != nil {
|
||||
writeError(w, http.StatusBadRequest, "invalid_request", "malformed json body")
|
||||
return
|
||||
}
|
||||
in.Recipient = strings.TrimSpace(in.Recipient)
|
||||
if in.Recipient == "" || strings.TrimSpace(in.Body) == "" {
|
||||
writeError(w, http.StatusBadRequest, "invalid_request", "recipient and body are required")
|
||||
return
|
||||
}
|
||||
|
||||
ctx := r.Context()
|
||||
tx, err := s.db.BeginTx(ctx, nil)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "begin transaction failed")
|
||||
return
|
||||
}
|
||||
defer tx.Rollback()
|
||||
|
||||
var stored []byte
|
||||
err = tx.QueryRowContext(ctx,
|
||||
`SELECT response FROM idempotency_keys WHERE key = $1 FOR UPDATE`, key).Scan(&stored)
|
||||
switch {
|
||||
case err == nil:
|
||||
if err := tx.Commit(); err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "commit failed")
|
||||
return
|
||||
}
|
||||
writeRawJSON(w, http.StatusOK, stored)
|
||||
return
|
||||
case !errors.Is(err, sql.ErrNoRows):
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "idempotency lookup failed")
|
||||
return
|
||||
}
|
||||
|
||||
var msg message
|
||||
err = tx.QueryRowContext(ctx,
|
||||
`INSERT INTO messages (sender_id, recipient, body)
|
||||
VALUES ($1, $2, $3)
|
||||
RETURNING id, sender_id, recipient, body, created_at`,
|
||||
sess.UserID, in.Recipient, in.Body,
|
||||
).Scan(&msg.ID, &msg.SenderID, &msg.Recipient, &msg.Body, &msg.CreatedAt)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "message insert failed")
|
||||
return
|
||||
}
|
||||
|
||||
payload, err := json.Marshal(msg)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "response encode failed")
|
||||
return
|
||||
}
|
||||
|
||||
if _, err := tx.ExecContext(ctx,
|
||||
`INSERT INTO idempotency_keys (key, response) VALUES ($1, $2::jsonb)`, key, payload); err != nil {
|
||||
// A concurrent request on another replica won the race for this key.
|
||||
tx.Rollback()
|
||||
var existing []byte
|
||||
if readErr := s.db.QueryRowContext(ctx,
|
||||
`SELECT response FROM idempotency_keys WHERE key = $1`, key).Scan(&existing); readErr == nil {
|
||||
writeRawJSON(w, http.StatusOK, existing)
|
||||
return
|
||||
}
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "idempotency store failed")
|
||||
return
|
||||
}
|
||||
|
||||
if err := tx.Commit(); err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "commit failed")
|
||||
return
|
||||
}
|
||||
|
||||
writeRawJSON(w, http.StatusCreated, payload)
|
||||
}
|
||||
|
||||
func (s *server) authenticate(r *http.Request) (*session, error) {
|
||||
token, ok := bearerToken(r)
|
||||
if !ok {
|
||||
return nil, errNoSession
|
||||
}
|
||||
|
||||
var sess session
|
||||
err := s.db.QueryRowContext(r.Context(),
|
||||
`SELECT s.user_id, u.login
|
||||
FROM sessions s
|
||||
JOIN users u ON u.id = s.user_id
|
||||
WHERE s.token = $1 AND s.expires_at > NOW()`, token).Scan(&sess.UserID, &sess.Login)
|
||||
if err != nil {
|
||||
return nil, errNoSession
|
||||
}
|
||||
return &sess, nil
|
||||
}
|
||||
|
||||
func bearerToken(r *http.Request) (string, bool) {
|
||||
header := r.Header.Get("Authorization")
|
||||
const prefix = "Bearer "
|
||||
if len(header) <= len(prefix) || !strings.EqualFold(header[:len(prefix)], prefix) {
|
||||
return "", false
|
||||
}
|
||||
token := strings.TrimSpace(header[len(prefix):])
|
||||
if token == "" {
|
||||
return "", false
|
||||
}
|
||||
return token, true
|
||||
}
|
||||
|
||||
func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) error {
|
||||
r.Body = http.MaxBytesReader(w, r.Body, 1<<20)
|
||||
decoder := json.NewDecoder(r.Body)
|
||||
return decoder.Decode(dst)
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, status int, body any) {
|
||||
payload, err := json.Marshal(body)
|
||||
if err != nil {
|
||||
http.Error(w, "response encode failed", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
writeRawJSON(w, status, payload)
|
||||
}
|
||||
|
||||
func writeRawJSON(w http.ResponseWriter, status int, payload []byte) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
w.Write(payload)
|
||||
}
|
||||
|
||||
func writeError(w http.ResponseWriter, status int, code, message string) {
|
||||
writeJSON(w, status, map[string]any{
|
||||
"error": map[string]string{
|
||||
"code": code,
|
||||
"message": message,
|
||||
},
|
||||
})
|
||||
}
|
||||
@@ -1,12 +1,11 @@
|
||||
# Topology worksheet, deliberately NOT a runnable stack (no application supplied).
|
||||
# Implement compose.yaml or stack.yaml; do not submit this empty file as deployment.
|
||||
# Service names below are logical roles, not imposed container names.
|
||||
x-lab-number: 4
|
||||
x-lab-number: 3
|
||||
x-required-roles:
|
||||
- api
|
||||
- postgres
|
||||
- load_balancer
|
||||
- s3
|
||||
# TODO: implement real images/builds, network wiring, volumes, healthchecks,
|
||||
# credentials and bootstrap. Details: contracts/infrastructure.json and README.md.
|
||||
services: {}
|
||||
|
||||
@@ -34,8 +34,7 @@
|
||||
"chat_id": "33333333-3333-4333-8333-333333333333",
|
||||
"sender_id": "11111111-1111-4111-8111-111111111111",
|
||||
"text": "Привет, Боб!",
|
||||
"created_at": "2026-09-01T12:00:00Z",
|
||||
"attachment_ids": []
|
||||
"created_at": "2026-09-01T12:00:00Z"
|
||||
},
|
||||
"MessagePage": {
|
||||
"items": [
|
||||
@@ -44,8 +43,7 @@
|
||||
"chat_id": "33333333-3333-4333-8333-333333333333",
|
||||
"sender_id": "11111111-1111-4111-8111-111111111111",
|
||||
"text": "Привет, Боб!",
|
||||
"created_at": "2026-09-01T12:00:00Z",
|
||||
"attachment_ids": []
|
||||
"created_at": "2026-09-01T12:00:00Z"
|
||||
}
|
||||
],
|
||||
"next_cursor": null
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
{
|
||||
"lab": 4,
|
||||
"lab": 3,
|
||||
"kind": "requirements, not runnable deployment",
|
||||
"required_for_grade_3": [
|
||||
{
|
||||
@@ -17,16 +17,6 @@
|
||||
"role": "load_balancer",
|
||||
"public_entrypoint": true,
|
||||
"backend_readiness": true
|
||||
},
|
||||
{
|
||||
"role": "s3",
|
||||
"choose_one": [
|
||||
"MinIO",
|
||||
"SeaweedFS",
|
||||
"RustFS"
|
||||
],
|
||||
"private_bucket": true,
|
||||
"persistent_volume": true
|
||||
}
|
||||
],
|
||||
"optional_components": [
|
||||
|
||||
+7
-985
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,105 @@
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16-alpine
|
||||
environment:
|
||||
POSTGRES_USER: app
|
||||
POSTGRES_PASSWORD: app
|
||||
POSTGRES_DB: app
|
||||
ports:
|
||||
- "5432:5432"
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U app -d app"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
networks:
|
||||
- lab3net
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 512M
|
||||
|
||||
api1:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
environment:
|
||||
APP_INSTANCE_ID: api1
|
||||
APP_PORT: "8080"
|
||||
DATABASE_URL: postgres://app:app@postgres:5432/app?sslmode=disable
|
||||
expose:
|
||||
- "8080"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "--spider", "-q", "http://localhost:8080/health"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
start_period: 10s
|
||||
stop_grace_period: 15s
|
||||
networks:
|
||||
- lab3net
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 256M
|
||||
|
||||
api2:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
environment:
|
||||
APP_INSTANCE_ID: api2
|
||||
APP_PORT: "8080"
|
||||
DATABASE_URL: postgres://app:app@postgres:5432/app?sslmode=disable
|
||||
expose:
|
||||
- "8080"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "--spider", "-q", "http://localhost:8080/health"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
start_period: 10s
|
||||
stop_grace_period: 15s
|
||||
networks:
|
||||
- lab3net
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 256M
|
||||
|
||||
haproxy:
|
||||
image: haproxy:2.9-alpine
|
||||
ports:
|
||||
- "8080:8080"
|
||||
volumes:
|
||||
- ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
|
||||
depends_on:
|
||||
api1:
|
||||
condition: service_healthy
|
||||
api2:
|
||||
condition: service_healthy
|
||||
networks:
|
||||
- lab3net
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 128M
|
||||
|
||||
networks:
|
||||
lab3net:
|
||||
driver: bridge
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
+28
-40
@@ -1,53 +1,41 @@
|
||||
# Optional HTTP-client worksheet; no extension is required by the course.
|
||||
# Replace IDs/token locally from real responses; do not commit filled-in credentials.
|
||||
# Canonical API: contracts/openapi.json and contracts/README.md.
|
||||
@baseUrl = http://localhost:8080
|
||||
@aliceId = REPLACE_WITH_CREATED_ALICE_UUID
|
||||
@bobId = REPLACE_WITH_CREATED_BOB_UUID
|
||||
@chatId = REPLACE_WITH_CREATED_CHAT_UUID
|
||||
@sessionToken = REPLACE_LOCALLY_DO_NOT_COMMIT
|
||||
### Health
|
||||
GET http://localhost:8080/health
|
||||
|
||||
### Liveness
|
||||
GET {{baseUrl}}/health/live
|
||||
|
||||
### Register Alice (repeat with username bob/display_name Боб)
|
||||
POST {{baseUrl}}/api/v1/users
|
||||
### Login
|
||||
POST http://localhost:8080/api/auth/login
|
||||
Content-Type: application/json
|
||||
|
||||
{
|
||||
"username": "alice",
|
||||
"display_name": "Алиса",
|
||||
"password": "Example-only-not-a-real-secret-123"
|
||||
"login": "test",
|
||||
"password": "test123"
|
||||
}
|
||||
|
||||
### Create session: generate the Base64 value locally, do not commit credentials
|
||||
# Base64 of UTF-8 username:password; only this endpoint accepts Basic.
|
||||
POST {{baseUrl}}/api/v1/auth/sessions
|
||||
Authorization: Basic REPLACE_WITH_LOCAL_BASE64_CREDENTIAL
|
||||
|
||||
|
||||
### Create chat; both UUIDs must be real registered users
|
||||
POST {{baseUrl}}/api/v1/chats
|
||||
Authorization: Bearer {{sessionToken}}
|
||||
Content-Type: application/json
|
||||
|
||||
{"title":"Проект по ВНП","member_ids":["{{aliceId}}","{{bobId}}"]}
|
||||
### Get messages
|
||||
GET http://localhost:8080/api/messages
|
||||
Authorization: Bearer TOKEN_HERE
|
||||
|
||||
### Send message
|
||||
POST {{baseUrl}}/api/v1/chats/{{chatId}}/messages
|
||||
Authorization: Bearer {{sessionToken}}
|
||||
Idempotency-Key: example-message-001
|
||||
POST http://localhost:8080/api/messages
|
||||
Authorization: Bearer TOKEN_HERE
|
||||
Idempotency-Key: unique-key-123
|
||||
Content-Type: application/json
|
||||
|
||||
{"text":"Привет, Боб!"}
|
||||
{
|
||||
"recipient": "test",
|
||||
"body": "Hello Bob"
|
||||
}
|
||||
|
||||
### Read first page
|
||||
GET {{baseUrl}}/api/v1/chats/{{chatId}}/messages?limit=50
|
||||
Authorization: Bearer {{sessionToken}}
|
||||
### Send the same message again (idempotent replay, same body and same key)
|
||||
POST http://localhost:8080/api/messages
|
||||
Authorization: Bearer TOKEN_HERE
|
||||
Idempotency-Key: unique-key-123
|
||||
Content-Type: application/json
|
||||
|
||||
### Binary upload; HTTP file-client syntax for reading local fixture
|
||||
POST {{baseUrl}}/api/v1/chats/{{chatId}}/attachments?filename=sample.png
|
||||
Authorization: Bearer {{sessionToken}}
|
||||
Content-Type: image/png
|
||||
{
|
||||
"recipient": "test",
|
||||
"body": "Hello Bob"
|
||||
}
|
||||
|
||||
< ../tests/fixtures/sample.png
|
||||
### Logout
|
||||
POST http://localhost:8080/api/auth/logout
|
||||
Authorization: Bearer TOKEN_HERE
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
module mtusi2026lab3
|
||||
|
||||
go 1.22
|
||||
|
||||
require (
|
||||
github.com/lib/pq v1.10.9
|
||||
golang.org/x/crypto v0.21.0
|
||||
)
|
||||
@@ -0,0 +1,4 @@
|
||||
github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
|
||||
github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
|
||||
golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
|
||||
golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
|
||||
@@ -0,0 +1,24 @@
|
||||
global
|
||||
log stdout format raw local0
|
||||
maxconn 4096
|
||||
|
||||
defaults
|
||||
mode http
|
||||
log global
|
||||
option httplog
|
||||
timeout connect 5s
|
||||
timeout client 30s
|
||||
timeout server 30s
|
||||
retries 2
|
||||
|
||||
frontend http_front
|
||||
bind *:8080
|
||||
default_backend api_back
|
||||
|
||||
backend api_back
|
||||
balance roundrobin
|
||||
option httpchk GET /health
|
||||
http-check expect status 200
|
||||
default-server inter 3s fall 3 rise 2
|
||||
server api1 api1:8080 check
|
||||
server api2 api2:8080 check
|
||||
@@ -0,0 +1,27 @@
|
||||
package config
|
||||
|
||||
import "os"
|
||||
|
||||
type Config struct {
|
||||
InstanceID string
|
||||
Port string
|
||||
DatabaseURL string
|
||||
}
|
||||
|
||||
func Load() *Config {
|
||||
cfg := &Config{
|
||||
InstanceID: os.Getenv("APP_INSTANCE_ID"),
|
||||
Port: os.Getenv("APP_PORT"),
|
||||
DatabaseURL: os.Getenv("DATABASE_URL"),
|
||||
}
|
||||
if cfg.InstanceID == "" {
|
||||
cfg.InstanceID = "api"
|
||||
}
|
||||
if cfg.Port == "" {
|
||||
cfg.Port = "8080"
|
||||
}
|
||||
if cfg.DatabaseURL == "" {
|
||||
panic("APP_INSTANCE_ID/APP_PORT optional; DATABASE_URL is required")
|
||||
}
|
||||
return cfg
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
package ident
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
)
|
||||
|
||||
const tokenBytes = 32
|
||||
|
||||
func GenerateToken() string {
|
||||
buf := make([]byte, tokenBytes)
|
||||
if _, err := rand.Read(buf); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return hex.EncodeToString(buf)
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id SERIAL PRIMARY KEY,
|
||||
login VARCHAR(64) UNIQUE NOT NULL,
|
||||
password_hash VARCHAR(255) NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS sessions (
|
||||
id SERIAL PRIMARY KEY,
|
||||
user_id INT REFERENCES users(id) ON DELETE CASCADE,
|
||||
token VARCHAR(255) UNIQUE NOT NULL,
|
||||
expires_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS messages (
|
||||
id SERIAL PRIMARY KEY,
|
||||
sender_id INT REFERENCES users(id),
|
||||
recipient VARCHAR(64) NOT NULL,
|
||||
body TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ DEFAULT NOW(),
|
||||
confirmed BOOLEAN DEFAULT false
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS idempotency_keys (
|
||||
key VARCHAR(255) PRIMARY KEY,
|
||||
response JSONB NOT NULL,
|
||||
created_at TIMESTAMPTZ DEFAULT NOW()
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_sessions_token ON sessions(token);
|
||||
CREATE INDEX IF NOT EXISTS idx_sessions_expires_at ON sessions(expires_at);
|
||||
CREATE INDEX IF NOT EXISTS idx_messages_recipient ON messages(recipient, id);
|
||||
-- Development seed: login "test", password "test123".
|
||||
INSERT INTO users (login, password_hash)
|
||||
VALUES ('test', '$2a$10$mS1fKWyAeTzjtao6iIuuGuxU9Yez9LEZXpxf7b30FB3Xb1wY./3bm')
|
||||
ON CONFLICT (login) DO NOTHING;
|
||||
@@ -0,0 +1,17 @@
|
||||
package password
|
||||
|
||||
import "golang.org/x/crypto/bcrypt"
|
||||
|
||||
const bcryptCost = 10
|
||||
|
||||
func Hash(password string) (string, error) {
|
||||
hashed, err := bcrypt.GenerateFromPassword([]byte(password), bcryptCost)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return string(hashed), nil
|
||||
}
|
||||
|
||||
func Check(password, hash string) bool {
|
||||
return bcrypt.CompareHashAndPassword([]byte(hash), []byte(password)) == nil
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"number": 4,
|
||||
"title": "S3-хранилище и вложения",
|
||||
"contract_version": "1.4.0",
|
||||
"number": 3,
|
||||
"title": "Балансировка и отказ API-реплики",
|
||||
"contract_version": "1.3.0",
|
||||
"default_base_url": "http://localhost:8080",
|
||||
"grading": "3; 4 includes 3; 5 includes 4 plus one completed research track",
|
||||
"scaffold_has_application": false
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
#!/usr/bin/env bash
|
||||
set -uo pipefail
|
||||
|
||||
REPLICA="${1:-api1}"
|
||||
|
||||
if [[ "$REPLICA" != "api1" && "$REPLICA" != "api2" ]]; then
|
||||
echo "Usage: $0 [api1|api2]"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "=== Starting $REPLICA ==="
|
||||
docker compose start "$REPLICA"
|
||||
sleep 10
|
||||
|
||||
echo "=== Status ==="
|
||||
docker compose ps
|
||||
|
||||
echo "=== Load balancing check ==="
|
||||
for i in 1 2 3 4; do
|
||||
curl -sI http://localhost:8080/health | grep -i x-instance-id
|
||||
done
|
||||
|
||||
exit 0
|
||||
@@ -0,0 +1,23 @@
|
||||
#!/usr/bin/env bash
|
||||
set -uo pipefail
|
||||
|
||||
REPLICA="${1:-${TARGET_INSTANCE_ID:-api1}}"
|
||||
|
||||
if [[ "$REPLICA" != "api1" && "$REPLICA" != "api2" ]]; then
|
||||
echo "Usage: $0 [api1|api2] (or set TARGET_INSTANCE_ID)"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "=== Stopping $REPLICA ==="
|
||||
docker compose stop "$REPLICA"
|
||||
|
||||
echo "=== Status ==="
|
||||
docker compose ps
|
||||
|
||||
echo "=== Health check ==="
|
||||
curl -s -o /dev/null -w "HTTP %{http_code}\n" http://localhost:8080/health
|
||||
|
||||
echo "=== X-Instance-Id ==="
|
||||
curl -sI http://localhost:8080/health | grep -i x-instance-id
|
||||
|
||||
exit 0
|
||||
+79
-199
@@ -1,217 +1,97 @@
|
||||
"""HTTP helpers for public black-box tests; Python 3.9+, standard library only."""
|
||||
import base64
|
||||
import datetime as dt
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import ssl
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
#!/usr/bin/env python3
|
||||
import sys
|
||||
import uuid
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
LAB = json.loads((ROOT / 'lab.json').read_text())['number']
|
||||
SPEC = json.loads((ROOT / 'contracts/openapi.json').read_text())
|
||||
import requests
|
||||
|
||||
BASE = "http://localhost:8080"
|
||||
LOGIN = "test"
|
||||
PASSWORD = "test123"
|
||||
TIMEOUT = 5
|
||||
|
||||
failures = []
|
||||
|
||||
class Failure(AssertionError):
|
||||
pass
|
||||
|
||||
def check(condition, message):
|
||||
if not condition:
|
||||
raise Failure(message)
|
||||
if condition:
|
||||
print("PASS:", message)
|
||||
return True
|
||||
failures.append(message)
|
||||
print("FAIL:", message)
|
||||
return False
|
||||
|
||||
def timestamp(value):
|
||||
check(isinstance(value, str) and value.endswith('Z'), 'timestamp must be UTC ending in Z')
|
||||
try:
|
||||
return dt.datetime.fromisoformat(value[:-1] + '+00:00')
|
||||
except ValueError as exc:
|
||||
raise Failure('invalid RFC3339 timestamp') from exc
|
||||
|
||||
def validate(value, schema, where='response'):
|
||||
"""Validate the JSON Schema subset used by the supplied contract, not arbitrary OpenAPI."""
|
||||
if '$ref' in schema:
|
||||
target = SPEC
|
||||
for part in schema['$ref'].split('/')[1:]:
|
||||
target = target[part]
|
||||
return validate(value, target, where)
|
||||
kinds = schema.get('type', [])
|
||||
if isinstance(kinds, str):
|
||||
kinds = [kinds]
|
||||
matches = {'null':value is None, 'boolean':isinstance(value,bool), 'integer':isinstance(value,int) and not isinstance(value,bool), 'number':isinstance(value,(int,float)) and not isinstance(value,bool), 'string':isinstance(value,str), 'array':isinstance(value,list), 'object':isinstance(value,dict)}
|
||||
if kinds:
|
||||
check(any(matches.get(k,False) for k in kinds), where + ': incorrect type')
|
||||
if 'enum' in schema:
|
||||
check(value in schema['enum'], where + ': invalid enum')
|
||||
if 'const' in schema:
|
||||
check(value == schema['const'], where + ': invalid const')
|
||||
if isinstance(value,dict):
|
||||
props = schema.get('properties',{})
|
||||
check(all(k in value for k in schema.get('required',[])), where + ': missing required fields')
|
||||
if schema.get('additionalProperties') is False:
|
||||
check(not set(value).difference(props), where + ': unexpected fields')
|
||||
for key, sub in props.items():
|
||||
if key in value:
|
||||
validate(value[key], sub, where + '.' + key)
|
||||
if isinstance(value,list):
|
||||
check(len(value) >= schema.get('minItems',0), where + ': too few items')
|
||||
check(len(value) <= schema.get('maxItems',float('inf')), where + ': too many items')
|
||||
if schema.get('uniqueItems'):
|
||||
encoded = [json.dumps(x,sort_keys=True) for x in value]
|
||||
check(len(encoded)==len(set(encoded)), where + ': duplicate items')
|
||||
if 'items' in schema:
|
||||
for item in value:
|
||||
validate(item, schema['items'], where + '[]')
|
||||
if isinstance(value,str):
|
||||
check(len(value) >= schema.get('minLength',0), where + ': too short')
|
||||
check(len(value) <= schema.get('maxLength',float('inf')), where + ': too long')
|
||||
if 'pattern' in schema:
|
||||
check(re.search(schema['pattern'], value) is not None, where + ': pattern mismatch')
|
||||
if schema.get('format') == 'uuid':
|
||||
try:
|
||||
uuid.UUID(value)
|
||||
except ValueError as exc:
|
||||
raise Failure(where + ': invalid UUID') from exc
|
||||
if schema.get('format') == 'date-time':
|
||||
timestamp(value)
|
||||
if isinstance(value,(int,float)) and not isinstance(value,bool):
|
||||
check(value >= schema.get('minimum',-float('inf')), where + ': below minimum')
|
||||
check(value <= schema.get('maximum',float('inf')), where + ': above maximum')
|
||||
if 'anyOf' in schema:
|
||||
for alternative in schema['anyOf']:
|
||||
try:
|
||||
validate(value, alternative, where)
|
||||
break
|
||||
except Failure:
|
||||
pass
|
||||
else:
|
||||
raise Failure(where + ': no anyOf branch matches')
|
||||
|
||||
def shape(value, name):
|
||||
validate(value, SPEC['components']['schemas'][name])
|
||||
return value
|
||||
|
||||
class NoRedirect(urllib.request.HTTPRedirectHandler):
|
||||
def redirect_request(self, req, fp, code, msg, headers, newurl):
|
||||
def login():
|
||||
response = requests.post(
|
||||
BASE + "/api/auth/login",
|
||||
json={"login": LOGIN, "password": PASSWORD},
|
||||
timeout=TIMEOUT,
|
||||
)
|
||||
if not check(response.status_code == 200, "login returns 200 (got %d)" % response.status_code):
|
||||
print(response.text)
|
||||
return None
|
||||
token = response.json().get("token")
|
||||
check(bool(token), "login returns a token")
|
||||
return token
|
||||
|
||||
class Client:
|
||||
def __init__(self, base_url=None, ca_file=None, timeout=10):
|
||||
self.base = (base_url or os.environ.get('BASE_URL') or ('https://localhost:8443' if LAB==7 else 'http://localhost:8080')).rstrip('/')
|
||||
check(self.base.startswith(('http://','https://')), 'BASE_URL must be HTTP(S)')
|
||||
check(LAB != 7 or self.base.startswith('https://'), 'lab7 requires HTTPS')
|
||||
self.timeout = timeout
|
||||
context = ssl.create_default_context(cafile=ca_file or os.environ.get('CA_FILE') or None)
|
||||
self.opener = urllib.request.build_opener(NoRedirect(), urllib.request.HTTPSHandler(context=context))
|
||||
|
||||
def call(self, method, path, expected=200, body=None, actor=None, headers=None, raw=None, schema=None):
|
||||
h = {'Accept':'application/json'}
|
||||
if actor:
|
||||
h['X-User-Id' if LAB==1 else 'Authorization'] = actor['id'] if LAB==1 else 'Bearer ' + actor['token']
|
||||
if body is not None:
|
||||
raw = json.dumps(body,ensure_ascii=False).encode('utf-8')
|
||||
h['Content-Type'] = 'application/json'
|
||||
h.update(headers or {})
|
||||
req = urllib.request.Request(self.base + path, data=raw, headers=h, method=method)
|
||||
start = time.monotonic()
|
||||
try:
|
||||
response = self.opener.open(req, timeout=self.timeout)
|
||||
except urllib.error.HTTPError as error:
|
||||
response = error
|
||||
except (urllib.error.URLError,TimeoutError,OSError) as exc:
|
||||
# Do not print URL query, headers, request body, or credentials.
|
||||
raise Failure(method + ' ' + path.split('?')[0] + ': connection/TLS failure (' + type(exc).__name__ + ')') from None
|
||||
with response:
|
||||
status = response.code
|
||||
rh = response.headers
|
||||
data = response.read(16*1024*1024 + 1)
|
||||
check(len(data) <= 16*1024*1024, 'response exceeds test safety limit')
|
||||
allowed = [expected] if isinstance(expected,int) else expected
|
||||
check(status in allowed, method + ' ' + path.split('?')[0] + ': expected ' + str(allowed) + ', received ' + str(status))
|
||||
check(bool(rh.get('X-Request-Id')), 'missing X-Request-Id')
|
||||
if LAB>=3:
|
||||
check(bool(rh.get('X-Instance-Id')), 'missing X-Instance-Id')
|
||||
payload = None
|
||||
if schema or status>=400:
|
||||
check(rh.get_content_type()=='application/json', 'expected application/json')
|
||||
try:
|
||||
payload = json.loads(data)
|
||||
except (ValueError,UnicodeError):
|
||||
raise Failure('invalid response JSON') from None
|
||||
shape(payload, 'Error' if status>=400 else schema)
|
||||
if status>=400:
|
||||
check(payload['error']['request_id']==rh.get('X-Request-Id'),'error request_id differs from header')
|
||||
if status==401 and LAB>=2:
|
||||
scheme = 'Basic' if path=='/api/v1/auth/sessions' else 'Bearer'
|
||||
check(rh.get('WWW-Authenticate','').lower().startswith(scheme.lower()), 'incorrect WWW-Authenticate challenge')
|
||||
if status==204:
|
||||
check(not data, '204 must not contain body')
|
||||
return {'status':status,'headers':rh,'json':payload,'bytes':data,'elapsed':time.monotonic()-start}
|
||||
def main():
|
||||
token = login()
|
||||
if token is None:
|
||||
return 1
|
||||
|
||||
def user(self, label):
|
||||
username = 'u_' + label + '_' + uuid.uuid4().hex[:12]
|
||||
password = 'T3st-' + uuid.uuid4().hex
|
||||
body = {'username':username,'display_name':'Студент ' + label}
|
||||
if LAB>=2:
|
||||
body['password'] = password
|
||||
user = self.call('POST','/api/v1/users',201,body=body,schema='User')['json']
|
||||
check(user['username']==username,'username changed')
|
||||
actor = {'id':user['id'],'user':user,'registration':body}
|
||||
if LAB>=2:
|
||||
credential = base64.b64encode((username+':'+password).encode()).decode()
|
||||
session = self.call('POST','/api/v1/auth/sessions',201,headers={'Authorization':'Basic '+credential},schema='Session')['json']
|
||||
check(session['user']==user,'session user mismatch')
|
||||
check(timestamp(session['expires_at']) > dt.datetime.now(dt.timezone.utc),'session already expired')
|
||||
actor['token'] = session['token']
|
||||
return actor
|
||||
auth = {"Authorization": "Bearer " + token}
|
||||
|
||||
def bootstrap(self):
|
||||
self.call('GET','/health/live',schema='Health')
|
||||
self.call('GET','/health/ready',schema='Health')
|
||||
alice, bob, eve = (self.user(label) for label in ('alice','bob','eve'))
|
||||
chat = self.call('POST','/api/v1/chats',201,actor=alice,body={'title':'Контрактный тест','member_ids':[alice['id'],bob['id']]},schema='Chat')['json']
|
||||
check(set(chat['member_ids'])=={alice['id'],bob['id']},'chat member mismatch')
|
||||
return alice,bob,eve,chat
|
||||
response = requests.get(BASE + "/api/messages", headers=auth, timeout=TIMEOUT)
|
||||
check(response.status_code == 200, "GET /api/messages returns 200")
|
||||
instance = response.headers.get("X-Instance-Id")
|
||||
check(bool(instance), "response carries X-Instance-Id (%s)" % instance)
|
||||
check(isinstance(response.json(), list), "GET /api/messages returns a JSON array")
|
||||
|
||||
def message(self, actor, chat, text, key=None, attachments=None):
|
||||
body = {'text':text}
|
||||
if attachments is not None:
|
||||
body['attachment_ids'] = attachments
|
||||
headers = {'Idempotency-Key':key or uuid.uuid4().hex} if LAB>=3 else {}
|
||||
return self.call('POST','/api/v1/chats/'+chat['id']+'/messages',201,actor=actor,body=body,headers=headers,schema='Message')
|
||||
key = "key-" + uuid.uuid4().hex[:12]
|
||||
body = {"recipient": LOGIN, "body": "hello " + uuid.uuid4().hex[:8]}
|
||||
|
||||
def attachment(self, actor, chat):
|
||||
content = (ROOT / 'tests/fixtures/sample.png').read_bytes()
|
||||
att = self.call('POST','/api/v1/chats/'+chat['id']+'/attachments?filename=sample.png',201 if LAB==4 else 202,actor=actor,raw=content,headers={'Content-Type':'image/png'},schema='Attachment')['json']
|
||||
check(att['status']==('ready' if LAB==4 else 'queued'),'incorrect upload status')
|
||||
check(att['chat_id']==chat['id'] and att['owner_id']==actor['id'],'attachment ownership mismatch')
|
||||
check(att['sha256']==hashlib.sha256(content).hexdigest() and att['size_bytes']==len(content),'original checksum/size mismatch')
|
||||
return att,content
|
||||
first = requests.post(
|
||||
BASE + "/api/messages",
|
||||
headers=dict(auth, **{"Idempotency-Key": key}),
|
||||
json=body,
|
||||
timeout=TIMEOUT,
|
||||
)
|
||||
check(first.status_code == 201, "first POST returns 201 (got %d)" % first.status_code)
|
||||
|
||||
def wait_ready(self, actor, att, wait_seconds=60):
|
||||
deadline = time.monotonic()+wait_seconds
|
||||
while time.monotonic()<deadline:
|
||||
att = self.call('GET','/api/v1/attachments/'+att['id'],actor=actor,schema='Attachment')['json']
|
||||
check(att['status']!='failed','attachment reached failed')
|
||||
if att['status']=='ready':
|
||||
return att
|
||||
time.sleep(0.3)
|
||||
raise Failure('attachment did not become ready within test deadline')
|
||||
second = requests.post(
|
||||
BASE + "/api/messages",
|
||||
headers=dict(auth, **{"Idempotency-Key": key}),
|
||||
json=body,
|
||||
timeout=TIMEOUT,
|
||||
)
|
||||
check(second.status_code in (200, 201), "replayed POST returns 2xx (got %d)" % second.status_code)
|
||||
|
||||
def arguments(description, configure=None):
|
||||
import argparse
|
||||
p = argparse.ArgumentParser(description=description)
|
||||
p.add_argument('--base-url', default=None)
|
||||
p.add_argument('--ca-file', default=None)
|
||||
if configure:
|
||||
configure(p)
|
||||
return p.parse_args()
|
||||
first_id = first.json().get("id")
|
||||
second_id = second.json().get("id")
|
||||
check(first_id is not None, "first POST returns message id")
|
||||
check(first_id == second_id, "replay returns the same id (%s vs %s)" % (first_id, second_id))
|
||||
|
||||
def run(main):
|
||||
missing_key = requests.post(BASE + "/api/messages", headers=auth, json=body, timeout=TIMEOUT)
|
||||
check(missing_key.status_code == 400, "POST without Idempotency-Key returns 400 (got %d)" % missing_key.status_code)
|
||||
|
||||
unauthorized = requests.get(BASE + "/api/messages", timeout=TIMEOUT)
|
||||
check(unauthorized.status_code == 401, "GET without token returns 401 (got %d)" % unauthorized.status_code)
|
||||
|
||||
messages = requests.get(BASE + "/api/messages", headers=auth, timeout=TIMEOUT).json()
|
||||
matching = [m for m in messages if m.get("body") == body["body"]]
|
||||
check(len(matching) == 1, "history contains exactly one copy of the message (got %d)" % len(matching))
|
||||
|
||||
if failures:
|
||||
print("\n%d check(s) failed" % len(failures))
|
||||
return 1
|
||||
print("\nAll API checks passed")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
main()
|
||||
except (Failure,ValueError,OSError) as exc:
|
||||
print('FAIL:', str(exc))
|
||||
raise SystemExit(1)
|
||||
sys.exit(main())
|
||||
except requests.RequestException as exc:
|
||||
print("request failed:", exc)
|
||||
sys.exit(1)
|
||||
|
||||
+157
-51
@@ -1,58 +1,164 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Small closed-loop HTTP write benchmark; not an open-loop capacity proof."""
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
import json
|
||||
import math
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
from client import Client, Failure, LAB, arguments, check, run
|
||||
from pathlib import Path
|
||||
|
||||
import requests
|
||||
|
||||
BASE = "http://localhost:8080"
|
||||
LOGIN = "test"
|
||||
PASSWORD = "test123"
|
||||
TIMEOUT = 5
|
||||
REPO_ROOT = Path(__file__).resolve().parents[1]
|
||||
RECOVERY_BUDGET = 10.0
|
||||
|
||||
failures = []
|
||||
|
||||
|
||||
def check(condition, message):
|
||||
if condition:
|
||||
print("PASS:", message)
|
||||
return True
|
||||
failures.append(message)
|
||||
print("FAIL:", message)
|
||||
return False
|
||||
|
||||
|
||||
def login():
|
||||
response = requests.post(
|
||||
BASE + "/api/auth/login",
|
||||
json={"login": LOGIN, "password": PASSWORD},
|
||||
timeout=TIMEOUT,
|
||||
)
|
||||
response.raise_for_status()
|
||||
return response.json()["token"]
|
||||
|
||||
|
||||
def fetch(token):
|
||||
response = requests.get(
|
||||
BASE + "/api/messages",
|
||||
headers={"Authorization": "Bearer " + token},
|
||||
timeout=TIMEOUT,
|
||||
)
|
||||
response.raise_for_status()
|
||||
return response.headers.get("X-Instance-Id", "")
|
||||
|
||||
|
||||
def round_robin(token, count):
|
||||
instances = []
|
||||
lock = threading.Lock()
|
||||
|
||||
def worker():
|
||||
try:
|
||||
instance = fetch(token)
|
||||
except requests.RequestException:
|
||||
return
|
||||
with lock:
|
||||
instances.append(instance)
|
||||
|
||||
threads = [threading.Thread(target=worker) for _ in range(count)]
|
||||
for thread in threads:
|
||||
thread.start()
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
return instances
|
||||
|
||||
|
||||
def compose(*args):
|
||||
return subprocess.run(
|
||||
["docker", "compose", *args],
|
||||
cwd=REPO_ROOT,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
check=False,
|
||||
)
|
||||
|
||||
|
||||
def main():
|
||||
def configure(p):
|
||||
p.add_argument('--duration',type=float,default=30)
|
||||
p.add_argument('--concurrency',type=int,default=4)
|
||||
p.add_argument('--output',default=None,help='Optional JSON metrics, no session tokens')
|
||||
args = arguments('Synthetic POST message load, closed loop; creates users/messages',configure)
|
||||
check(1<=args.duration<=3600,'duration must be 1..3600 seconds')
|
||||
check(1<=args.concurrency<=128,'concurrency must be 1..128')
|
||||
c = Client(args.base_url,args.ca_file)
|
||||
alice,bob,eve,chat = c.bootstrap()
|
||||
barrier = threading.Barrier(args.concurrency)
|
||||
def worker(worker_id):
|
||||
local = Client(args.base_url,args.ca_file,timeout=5)
|
||||
barrier.wait()
|
||||
deadline = time.monotonic()+args.duration
|
||||
latencies,errors = [],0
|
||||
index = 0
|
||||
while time.monotonic()<deadline:
|
||||
start = time.monotonic()
|
||||
try:
|
||||
local.message(alice,chat,'load-%s-%s' % (worker_id,index))
|
||||
latencies.append(time.monotonic()-start)
|
||||
except Failure:
|
||||
errors += 1
|
||||
index += 1
|
||||
return latencies,errors
|
||||
started = time.monotonic()
|
||||
with ThreadPoolExecutor(max_workers=args.concurrency) as pool:
|
||||
results = list(pool.map(worker,range(args.concurrency)))
|
||||
elapsed = time.monotonic()-started
|
||||
latencies = sorted(x for values,_ in results for x in values)
|
||||
errors = sum(n for _,n in results)
|
||||
total = len(latencies)+errors
|
||||
def percentile(p):
|
||||
return round(1000*latencies[max(0,math.ceil(p*len(latencies))-1)],3) if latencies else None
|
||||
report = {'lab':LAB,'workload':'closed-loop POST messages; no automatic retries','requested_duration_seconds':args.duration,'elapsed_seconds':round(elapsed,3),'concurrency':args.concurrency,'successful_requests':len(latencies),'failed_requests':errors,'error_ratio':round(errors/total,6) if total else None,'successful_rps':round(len(latencies)/elapsed,3),'successful_latency_ms':{'p50':percentile(.50),'p95':percentile(.95),'p99':percentile(.99)},'note':'Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.'}
|
||||
text = json.dumps(report,ensure_ascii=False,indent=2)
|
||||
if args.output:
|
||||
dest = Path(args.output)
|
||||
dest.parent.mkdir(parents=True,exist_ok=True)
|
||||
dest.write_text(text+'\n')
|
||||
print(text)
|
||||
check(bool(latencies),'no successful writes')
|
||||
# Errors are reported, not treated as a universal load-test threshold.
|
||||
token = login()
|
||||
auth = {"Authorization": "Bearer " + token}
|
||||
|
||||
if __name__=='__main__':
|
||||
run(main)
|
||||
probe = requests.post(
|
||||
BASE + "/api/messages",
|
||||
headers=dict(auth, **{"Idempotency-Key": "load-" + str(time.time_ns())}),
|
||||
json={"recipient": LOGIN, "body": "before failover"},
|
||||
timeout=TIMEOUT,
|
||||
)
|
||||
check(probe.status_code == 201, "message written before failover (got %d)" % probe.status_code)
|
||||
probe_id = probe.json().get("id")
|
||||
|
||||
instances = round_robin(token, 20)
|
||||
check(len(set(instances)) >= 2, "requests reached at least two replicas: %s" % sorted(set(instances)))
|
||||
|
||||
print("\n=== Stopping api1 ===")
|
||||
stop = compose("stop", "api1")
|
||||
check(stop.returncode == 0, "docker compose stop api1 succeeded")
|
||||
started = time.monotonic()
|
||||
|
||||
recovered_at = None
|
||||
served_after = []
|
||||
transient_errors = 0
|
||||
while time.monotonic() - started < RECOVERY_BUDGET + 5:
|
||||
try:
|
||||
instance = fetch(token)
|
||||
except requests.RequestException:
|
||||
transient_errors += 1
|
||||
time.sleep(0.2)
|
||||
continue
|
||||
if recovered_at is None:
|
||||
recovered_at = time.monotonic() - started
|
||||
served_after.append(instance)
|
||||
if len(served_after) >= 5:
|
||||
break
|
||||
time.sleep(0.1)
|
||||
|
||||
check(
|
||||
recovered_at is not None and recovered_at <= RECOVERY_BUDGET,
|
||||
"reads recovered within %.0fs (%.2fs, %d transient errors)"
|
||||
% (RECOVERY_BUDGET, recovered_at if recovered_at is not None else -1, transient_errors),
|
||||
)
|
||||
check(bool(served_after), "requests still served while api1 is down")
|
||||
check(all(x == "api2" for x in served_after), "api1 left rotation, served by: %s" % sorted(set(served_after)))
|
||||
|
||||
write = requests.post(
|
||||
BASE + "/api/messages",
|
||||
headers=dict(auth, **{"Idempotency-Key": "load-fail-" + str(time.time_ns())}),
|
||||
json={"recipient": LOGIN, "body": "written during failover"},
|
||||
timeout=TIMEOUT,
|
||||
)
|
||||
check(write.status_code == 201, "write works while api1 is down (got %d)" % write.status_code)
|
||||
|
||||
print("\n=== Starting api1 back ===")
|
||||
start = compose("start", "api1")
|
||||
check(start.returncode == 0, "docker compose start api1 succeeded")
|
||||
|
||||
deadline = time.monotonic() + 30
|
||||
back = set()
|
||||
while time.monotonic() < deadline:
|
||||
back = set(round_robin(token, 10))
|
||||
if "api1" in back:
|
||||
break
|
||||
time.sleep(1)
|
||||
check("api1" in back, "api1 is back in rotation: %s" % sorted(back))
|
||||
|
||||
history = requests.get(BASE + "/api/messages", headers=auth, timeout=TIMEOUT)
|
||||
check(history.status_code == 200, "history readable after failover (got %d)" % history.status_code)
|
||||
ids = [m.get("id") for m in history.json()]
|
||||
check(probe_id in ids, "message written before failover survived")
|
||||
check(len(ids) == len(set(ids)), "no duplicate messages in history")
|
||||
|
||||
if failures:
|
||||
print("\n%d check(s) failed" % len(failures))
|
||||
return 1
|
||||
print("\nFailover scenario passed")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
sys.exit(main())
|
||||
except requests.RequestException as exc:
|
||||
print("request failed:", exc)
|
||||
sys.exit(1)
|
||||
|
||||
Reference in New Issue
Block a user