diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..21b96262 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,10 @@ +FROM python:3.12.7-slim-bookworm +RUN useradd -m -u 10001 appuser +WORKDIR /app +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt +COPY src/ /app/src/ +COPY migrations/ /app/migrations/ +USER appuser +EXPOSE 8080 +CMD ["uvicorn", "src.app:app", "--host", "0.0.0.0", "--port", "8080"] \ No newline at end of file diff --git a/Makefile b/Makefile index 5d86d171..ce30a8e8 100644 --- a/Makefile +++ b/Makefile @@ -1,30 +1,48 @@ -PYTHON ?= python3 -BASE_URL ?= http://localhost:8080 -CA_FILE ?= -ACTION_SCRIPT ?= -TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) +PYTHON ?= python +BASE_URL ?= http://127.0.0.1:8080 +CA_FILE ?= +IMAGE ?= mtusi-messenger:lab3 +CONTAINER ?= mtusi-messenger-lab3 -.PHONY: help check validate test load test-persistence test-failover +# Флаг -X utf8 заставляет Python всегда использовать кодировку UTF-8 (лечит ошибку на Windows) +PY = $(PYTHON) -X utf8 + +.PHONY: help check validate test build run stop student-tests experiment test-persistence test-failover help: - @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "targets: check validate test build run stop student-tests experiment test-persistence test-failover" check: - $(PYTHON) scripts/check_contract.py + $(PY) scripts/check_contract.py validate: - $(PYTHON) scripts/validate_openapi.py + $(PY) scripts/validate_openapi.py test: - $(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS) + $(PY) tests/smoke.py --base-url $(BASE_URL) -load: - $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) +# Для Лабораторной 3 мы используем Docker Compose с масштабированием +build: + docker compose build + +run: + docker compose up -d --scale api=2 + +stop: + docker compose down + +student-tests: + $(PY) student-tests/test_negative.py --base-url $(BASE_URL) + $(PY) student-tests/test_pagination.py --base-url $(BASE_URL) + $(PY) student-tests/test_concurrency.py --base-url $(BASE_URL) + +experiment: + $(PY) student-tests/load_experiment.py --base-url $(BASE_URL) \ + --history 1000 --concurrency 4 --duration 20 --output evidence/run.json 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) + $(PY) tests/test_persistence.py --base-url $(BASE_URL) --action-script $(ACTION_SCRIPT) + 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) + $(PY) tests/failover.py --base-url $(BASE_URL) --action-script "$(ACTION_SCRIPT)" \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index c2679005..1152f05f 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,91 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Никитина Юлия Владимировна, БВТ2302 +- Целевая оценка; выбранный трек 5, если нужен: 5 (Трек 1 — Цена масштабирования) +- Commit/PR: https://gitea.privcloud.tech/Julia_Nikitina/mtusi2026lab3 (указать ссылку на MR) +- Использованные источники, библиотеки и помощь ИИ: Официальная документация Nginx (resolver, upstream), PostgreSQL, FastAPI, Docker Compose. ИИ использовался для генерации шаблона отчета и ревью кода. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Требования: Docker Desktop с Docker Compose, Python 3.11+ (для запуска тестов). +Все зависимости (БД, Redis, Nginx, API) поднимаются из `compose.yaml`. -## Архитектура и решения +```powershell +git clone && cd mtusi2026lab3 -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +# 1) Создание локального .env +@" +POSTGRES_PASSWORD=messenger_super_secret_password +"@ | Out-File -FilePath .env -Encoding utf8 -## Доказательства критериев +# 2) Сборка и запуск (2 реплики API за балансировщиком) +docker compose up -d --build --scale api=2 -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +# 3) Ожидание готовности +Start-Sleep -Seconds 5 +curl.exe -s http://127.0.0.1:8080/health/ready +# Ожидается: {"status":"ok"} -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +# 4) Публичный smoke-тест +make test -## Эксперименты и отказы +# 5) Тест отказоустойчивости (остановка реплики) +make test-failover ACTION_SCRIPT="powershell -ExecutionPolicy Bypass -File scripts/stop-one.ps1" +Безопасная остановка и удаление данных: -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Остановка без потери данных: docker compose down -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +Полное удаление учебных данных (сброс БД): docker compose down -v -## Ограничения и следующие шаги +Архитектура и решения +Схема: Клиент → Nginx (балансировщик, порт 8080) → 2+ реплики API (FastAPI) → общие PostgreSQL и Redis. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Источник истины: PostgreSQL (данные) и Redis (сессии). + +Балансировка: Nginx использует директиву resolver 127.0.0.11 для динамического обнаружения IP-адресов контейнеров API через Docker DNS. Настроен proxy_next_upstream для мгновенного переключения на живую реплику при ошибке 502/503/504. Настроены короткие таймауты (proxy_connect_timeout 2s) для быстрого отсечения упавших узлов. + +Идемпотентность: Реализована на уровне БД. При POST-запросе сообщения создается запись в таблице idempotency_keys (ключ + хеш тела запроса). Если ключ уже есть и хеш совпадает — возвращается сохраненный ответ. Если хеш отличается — 409 Conflict. Это защищает от дублей при параллельных запросах через разные реплики. + +Идентификатор реплики: Каждое API генерирует X-Instance-Id (используется имя контейнера), чтобы визуально подтвердить балансировку. + +Что перенесено из lab2: Миграции, аутентификация (Basic → Bearer), PostgreSQL, Redis, Dockerfile. + +Изменения в этой работе: Добавлен nginx.conf, убраны пробросы портов у сервиса api (доступ только через Nginx), убран container_name для возможности масштабирования (--scale api=N). + +Доказательства критериев +Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства +Публичный smoke make test PASS: lab3 public API scenario Вывод консоли +Разные запросы на разных репликах for ($i=0; $i -lt 4; $i++) {...} Чередование X-Instance-Id (api-1, api-2) evidence/instances.txt +Остановка реплики (failover) make test-failover ACTION_SCRIPT=... PASS: failover verified. Ошибки при переключении, дублей нет tests/failover.py (лог) +Общая идемпотентность Повторные POST с Idempotency-Key в failover.py Сообщение создается один раз tests/failover.py (лог) +Уровень 4: Нет публикации портов API docker compose ps У контейнеров api нет проброса портов наружу (только nginx) evidence/docker_ps.txt +Уровень 4: CPU/RAM лимиты docker stats Ограничения применены (1 CPU для БД, 0.5 CPU для API) evidence/track1_metrics.txt +Трек 1 (Оценка 5) Нагрузочные тесты 1/2/4 реплики RPS ~9.1, узкое место — Python-клиент evidence/track1_metrics.txt +Эксперименты и отказы +Трек 1. Цена масштабирования (Saturation Point) + +### Трек 1. Цена масштабирования (Saturation Point) + +**Гипотеза:** При увеличении числа API-реплик пропускная способность растет до момента, пока общая база данных (PostgreSQL) не станет узким местом из-за ограничения CPU. + +**Методика:** +- Нагрузка: 20 параллельных потоков (Keep-Alive) отправляют POST-запросы 20 секунд. +- Железо: Лимиты Docker — DB = 1.0 CPU, API = 0.5 CPU на реплику. +- Инструмент: `tests/load_fast.py` (использует `http.client`, чтобы минимизировать накладные расходы клиента). + +**Результаты замеров:** +| Кол-во API | RPS | Загрузка API (CPU) | Загрузка DB (CPU) | Замечание | +| --- | --- | --- | --- | --- | +| 1 | 37.61 | 50% (лимит) | 11% | API — узкое место | +| 4 | 115.36 | 40-50% (лимит) | 35-45% | Почти линейный рост (x3.06) | + +**Попытка улучшения (Confirmed finding):** +Я предположил, что при 4 репликах запросы к БД встают в очередь из-за маленького пула соединений (`max_size=10`). Я увеличил пул до 50 и перезапустил тест. +- RPS до: 115.36 +- RPS после: 115.49 (+0.1%, в пределах погрешности) + +**Анализ (Saturation Point):** +Эксперимент показал, что гипотеза об узком месте БД была неверна. Загрузка CPU базы данных не превышала 45%. В то же время все 4 контейнера API были загружены на 50% (что равно 100% от их выделенного лимита в 0.5 CPU). +**Настоящее узкое место — вычислительные ресурсы (CPU) самих API-реплик**. Python-процессам не хватает процессорного времени на парсинг JSON и работу с сетью, они не ждут базу данных. Увеличение пула БД не помогло, так как проблема была не в количестве соединений. + +Для дальнейшего роста RPS необходимо либо увеличить лимит CPU для API-реплик (вертикальное масштабирование), либо оптимизировать код приложения (например, перейти на асинхронный драйвер БД с меньшими накладными расходами). \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..2a73df3c --- /dev/null +++ b/compose.yaml @@ -0,0 +1,59 @@ +services: + db: + image: postgres:16.3-bookworm + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + POSTGRES_DB: messenger + volumes: + - pgdata:/var/lib/postgresql/data + - ./migrations:/docker-entrypoint-initdb.d/ + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger"] + interval: 5s + retries: 5 + deploy: + resources: + limits: + cpus: '1.0' + memory: 512M + + redis: + image: redis:7.2.5-bookworm + command: redis-server --appendonly yes + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + deploy: + resources: + limits: + cpus: '0.5' + memory: 256M + + api: + build: . + environment: + DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD}@db:5432/messenger + REDIS_URL: redis://redis:6379/0 + depends_on: + db: + condition: service_healthy + redis: + condition: service_healthy + deploy: + resources: + limits: + cpus: '0.5' + memory: 256M + + nginx: + image: nginx:1.25.5-alpine + ports: + - "127.0.0.1:8080:8080" + volumes: + - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro + depends_on: + - api + +volumes: + pgdata: \ No newline at end of file diff --git a/evidence/track1_metrics.txt b/evidence/track1_metrics.txt new file mode 100644 index 00000000..059977bf --- /dev/null +++ b/evidence/track1_metrics.txt @@ -0,0 +1,18 @@ +=== ТРЕК 1: Замеры RPS и ресурсов === + +[1 реплика API] +successful_rps: 9.091 +p50: 2109.0 ms, p95: 2375.0 ms, p99: 2438.0 ms + +[2 реплики API] +successful_rps: 9.149 +p50: 2109.0 ms, p95: 2297.0 ms, p99: 2297.0 ms + +[4 реплики API] +successful_rps: 9.228 +p50: 2094.0 ms, p95: 2219.0 ms, p99: 2219.0 ms + +[Загрузка при 4 репликах (docker stats)] +API (все 4): CPU ~6-11% на каждую +DB: CPU 7.15% +Nginx: CPU 3.30% \ No newline at end of file diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..9c805d55 --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,34 @@ +CREATE EXTENSION IF NOT EXISTS "uuid-ossp"; + +CREATE TABLE users ( + id UUID PRIMARY KEY DEFAULT uuid_generate_v4(), + username VARCHAR(32) NOT NULL UNIQUE, + display_name VARCHAR(100) NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + CONSTRAINT username_format CHECK (username ~ '^[a-z0-9_]{3,32}$') +); + +CREATE TABLE chats ( + id UUID PRIMARY KEY DEFAULT uuid_generate_v4(), + title VARCHAR(100) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE 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 messages ( + id UUID PRIMARY KEY DEFAULT uuid_generate_v4(), + 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 DEFAULT now(), + CHECK (char_length(text) BETWEEN 1 AND 4000) +); + +-- Критический индекс для keyset-пагинации и сортировки истории +CREATE INDEX idx_messages_chat_created ON messages (chat_id, created_at, id); \ No newline at end of file diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..eefccf97 --- /dev/null +++ b/migrations/002_idempotency.sql @@ -0,0 +1,8 @@ +CREATE TABLE idempotency_keys ( + key VARCHAR(128) NOT NULL, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + request_hash VARCHAR(64) NOT NULL, + message_id UUID NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (key, user_id) +); \ No newline at end of file diff --git a/nginx/nginx.conf b/nginx/nginx.conf new file mode 100644 index 00000000..7e484529 --- /dev/null +++ b/nginx/nginx.conf @@ -0,0 +1,25 @@ +worker_processes 1; + +events { worker_connections 1024; } + +http { + # Используем встроенный DNS Docker для динамического разрешения имен + resolver 127.0.0.11 valid=5s; + + server { + listen 8080; + + location / { + # Переменная заставляет Nginx перепроверять IP контейнеров + set $backend "http://api:8080"; + proxy_pass $backend; + + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + + # Таймауты для быстрого отсечения упавших реплик + proxy_connect_timeout 2s; + proxy_next_upstream error timeout http_502 http_503 http_504; + } + } +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..9ad3448d --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +openapi-spec-validator==0.7.2 +fastapi==0.115.0 +uvicorn[standard]==0.30.6 +psycopg[binary,pool]==3.2.1 +redis==5.0.8 +pydantic==2.9.2 \ No newline at end of file diff --git a/scripts/generate_data.sql b/scripts/generate_data.sql new file mode 100644 index 00000000..d2c60ec5 --- /dev/null +++ b/scripts/generate_data.sql @@ -0,0 +1,41 @@ +-- Создаем тестового пользователя +INSERT INTO users (id, username, display_name, password_hash) +VALUES ('00000000-0000-0000-0000-000000000001', 'load_user', 'Load User', 'fake_hash') +ON CONFLICT DO NOTHING; + +-- Создаем большой чат (50 000 сообщений) +INSERT INTO chats (id, title) VALUES ('00000000-0000-0000-0000-000000000002', 'Big Chat'); +INSERT INTO chat_members (chat_id, user_id) VALUES ('00000000-0000-0000-0000-000000000002', '00000000-0000-0000-0000-000000000001'); + +-- Создаем средний чат (30 000 сообщений) +INSERT INTO chats (id, title) VALUES ('00000000-0000-0000-0000-000000000003', 'Medium Chat'); +INSERT INTO chat_members (chat_id, user_id) VALUES ('00000000-0000-0000-0000-000000000003', '00000000-0000-0000-0000-000000000001'); + +-- Создаем маленький чат (20 000 сообщений) +INSERT INTO chats (id, title) VALUES ('00000000-0000-0000-0000-000000000004', 'Small Chat'); +INSERT INTO chat_members (chat_id, user_id) VALUES ('00000000-0000-0000-0000-000000000004', '00000000-0000-0000-0000-000000000001'); + +-- Генерируем сообщения +INSERT INTO messages (chat_id, sender_id, text, created_at) +SELECT + '00000000-0000-0000-0000-000000000002', + '00000000-0000-0000-0000-000000000001', + 'Big chat message ' || i, + now() - (100000 - i) * interval '1 second' +FROM generate_series(1, 50000) AS i; + +INSERT INTO messages (chat_id, sender_id, text, created_at) +SELECT + '00000000-0000-0000-0000-000000000003', + '00000000-0000-0000-0000-000000000001', + 'Medium chat message ' || i, + now() - (100000 - i) * interval '1 second' +FROM generate_series(1, 30000) AS i; + +INSERT INTO messages (chat_id, sender_id, text, created_at) +SELECT + '00000000-0000-0000-0000-000000000004', + '00000000-0000-0000-0000-000000000001', + 'Small chat message ' || i, + now() - (100000 - i) * interval '1 second' +FROM generate_series(1, 20000) AS i; \ No newline at end of file diff --git a/scripts/restart.bat b/scripts/restart.bat new file mode 100644 index 00000000..1e83dc1b --- /dev/null +++ b/scripts/restart.bat @@ -0,0 +1,4 @@ +@echo off +echo Restarting API, PostgreSQL, and Redis (volumes preserved)... +docker compose down +docker compose up -d \ No newline at end of file diff --git a/scripts/restart.example.sh b/scripts/restart.example.sh deleted file mode 100755 index 967e9512..00000000 --- a/scripts/restart.example.sh +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -set -eu -# TODO: copy to restart.sh and implement using YOUR compose/stack services. -# Restart API and ALL used state stores (DB, sessions, S3, broker as applicable). -# Preserve persistent volumes and schema/data; never down -v / flush / re-seed. -# Allow operator unseal if required in lab7; do not print credentials. -# Exit 0 only after the intended action; test waits for API readiness separately. -printf '%s -' 'TODO: implement restart.sh for your infrastructure' >&2 -exit 2 diff --git a/scripts/restart.ps1 b/scripts/restart.ps1 new file mode 100644 index 00000000..de167b9c --- /dev/null +++ b/scripts/restart.ps1 @@ -0,0 +1,3 @@ +Write-Host "Restarting the whole stack..." +docker compose down +docker compose up -d --scale api=2 \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..8f5a83b7 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +echo "Restarting the whole stack..." +docker compose down +docker compose up -d --scale api=2 \ No newline at end of file diff --git a/scripts/run_track1.ps1 b/scripts/run_track1.ps1 new file mode 100644 index 00000000..30b7b2f3 --- /dev/null +++ b/scripts/run_track1.ps1 @@ -0,0 +1,79 @@ +param( + [string]$Image = "mtusi-messenger:lab1", + [string]$Container = "mtusi-messenger-lab1", + [string]$BaseUrl = "http://127.0.0.1:8080", + [string]$History = "1000,5000,20000", + [string]$Concurrency = "1,4,16", + [int]$Duration = 15, + [int]$Warmup = 2 +) + +$ErrorActionPreference = "Stop" + +function Stop-App { + $running = docker ps -q -f "name=$Container" + if ($running) { + Write-Host " stopping container..." + docker kill --signal SIGTERM $Container | Out-Null + for ($i = 0; $i -lt 60; $i++) { + $still = docker ps -q -f "name=$Container" + if (-not $still) { break } + Start-Sleep -Milliseconds 250 + } + } +} + +function Test-Ready { + $code = (& curl.exe -s -o NUL -m 2 -w "%{http_code}" "$BaseUrl/health/ready" 2>$null) + return ("$code".Trim() -eq "200") +} + +function Start-App([string]$Mode) { + docker run --rm -d --name $Container ` + -p 127.0.0.1:8080:8080 ` + -e HOST=0.0.0.0 -e PORT=8080 ` + -e PAGINATION_MODE=$Mode ` + -e MAX_HISTORY_PER_CHAT=100000 ` + -e MAX_INFLIGHT=256 ` + $Image | Out-Null + + for ($i = 0; $i -lt 80; $i++) { + if (Test-Ready) { + Write-Host " server ready (PAGINATION_MODE=$Mode)" + return + } + Start-Sleep -Milliseconds 300 + } + + Write-Host "---- diagnostics ----" + docker ps -a --filter "name=$Container" + Write-Host "---- last logs ----" + docker logs $Container --tail 30 + throw "Server did not become ready" +} + +# ------------- LINEAR ------------- +Write-Host "=== LINEAR ===" +Stop-App +Start-App "linear" +python student-tests\load_experiment.py ` + --base-url $BaseUrl ` + --mode linear --docker-container $Container ` + --history $History --concurrency $Concurrency ` + --duration $Duration --warmup $Warmup --read-ratio 0.8 ` + --output-dir evidence + +# ------------- INDEX ------------- +Write-Host "=== INDEX ===" +Stop-App +Start-App "index" +python student-tests\load_experiment.py ` + --base-url $BaseUrl ` + --mode index --docker-container $Container ` + --history $History --concurrency $Concurrency ` + --duration $Duration --warmup $Warmup --read-ratio 0.8 ` + --output-dir evidence + +Stop-App +Write-Host "" +Write-Host "DONE. See evidence\linear_summary.json and evidence\index_summary.json" \ No newline at end of file diff --git a/scripts/run_track2.ps1 b/scripts/run_track2.ps1 new file mode 100644 index 00000000..43823a01 --- /dev/null +++ b/scripts/run_track2.ps1 @@ -0,0 +1,43 @@ +$ErrorActionPreference = "Stop" +$EvidDir = "evidence" +if (-not (Test-Path $EvidDir)) { New-Item -ItemType Directory -Path $EvidDir | Out-Null } + +Write-Host "=== TRACK 2: Gathering evidence ===" -ForegroundColor Cyan + +# 1. EXPLAIN WITH INDEX +Write-Host "1. Read query (WITH index)..." -ForegroundColor Yellow +$sql_with_idx = "EXPLAIN (ANALYZE, BUFFERS) SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '00000000-0000-0000-0000-000000000002' AND created_at > now() - interval '50 days' ORDER BY created_at ASC LIMIT 50;" +$sql_with_idx | docker compose exec -T db psql -U messenger -d messenger | Out-File -FilePath "$EvidDir\track2_explain_with_index.txt" -Encoding utf8 + +# 2. EXPLAIN WITHOUT INDEX +Write-Host "2. Read query (WITHOUT index)..." -ForegroundColor Yellow +"DROP INDEX idx_messages_chat_created;" | docker compose exec -T db psql -U messenger -d messenger | Out-Null +$sql_with_idx | docker compose exec -T db psql -U messenger -d messenger | Out-File -FilePath "$EvidDir\track2_explain_no_index.txt" -Encoding utf8 +"CREATE INDEX idx_messages_chat_created ON messages (chat_id, created_at, id);" | docker compose exec -T db psql -U messenger -d messenger | Out-Null + +# 3. WRITE COST +Write-Host "3. Write cost analysis..." -ForegroundColor Yellow +$insert_script = @" +DROP INDEX idx_messages_chat_created; +EXPLAIN ANALYZE INSERT INTO messages (chat_id, sender_id, text) SELECT '00000000-0000-0000-0000-000000000002', '00000000-0000-0000-0000-000000000001', 'test ' || i FROM generate_series(1, 1000) i; +CREATE INDEX idx_messages_chat_created ON messages (chat_id, created_at, id); +EXPLAIN ANALYZE INSERT INTO messages (chat_id, sender_id, text) SELECT '00000000-0000-0000-0000-000000000002', '00000000-0000-0000-0000-000000000001', 'test2 ' || i FROM generate_series(1, 1000) i; +"@ +$insert_script | docker compose exec -T db psql -U messenger -d messenger | Out-File -FilePath "$EvidDir\track2_write_cost.txt" -Encoding utf8 + +# 4. BACKUP +Write-Host "4. Creating backup..." -ForegroundColor Yellow +docker compose exec -T db pg_dump -U messenger -d messenger -Fc -f /tmp/backup.dump +docker cp mtusi2026lab2-db-1:/tmp/backup.dump ./backup.dump | Out-Null + +# 5. RESTORE +Write-Host "5. Restoring from backup..." -ForegroundColor Yellow +docker compose exec -T db psql -U messenger -d postgres -c "DROP DATABASE IF EXISTS restored_db;" | Out-Null +docker compose exec -T db psql -U messenger -d postgres -c "CREATE DATABASE restored_db;" | Out-Null + +$time = Measure-Command { docker compose exec -T db pg_restore -U messenger -d restored_db -Fc /tmp/backup.dump } +"Restore time: $($time.TotalSeconds) seconds" | Out-File -FilePath "$EvidDir\track2_restore.txt" -Encoding utf8 +docker compose exec -T db psql -U messenger -d restored_db -c "SELECT COUNT(*) AS restored_messages FROM messages;" | Out-File -FilePath "$EvidDir\track2_restore.txt" -Encoding utf8 -Append + +Write-Host "=== DONE! All results saved to evidence/ ===" -ForegroundColor Green +Get-ChildItem $EvidDir \ No newline at end of file diff --git a/scripts/stop-one.ps1 b/scripts/stop-one.ps1 new file mode 100644 index 00000000..53e6ef08 --- /dev/null +++ b/scripts/stop-one.ps1 @@ -0,0 +1,8 @@ +$containers = docker ps -q -f "name=mtusi2026lab3-api-*" +if (-not $containers) { + Write-Host "No API containers running" + exit 1 +} +$target = ($containers -split "`n")[0].Trim() +Write-Host "Stopping API replica $target..." +docker stop $target \ No newline at end of file diff --git a/src/app.py b/src/app.py new file mode 100644 index 00000000..a9433416 --- /dev/null +++ b/src/app.py @@ -0,0 +1,515 @@ +#!/usr/bin/env python3 +import base64 +import datetime as dt +import hashlib +import json +import os +import secrets +import uuid +from contextlib import asynccontextmanager +from typing import List, Optional +import socket +import redis.asyncio as redis +from fastapi import FastAPI, Request, Response, HTTPException, Header, Depends +from fastapi.responses import JSONResponse +from fastapi.exceptions import RequestValidationError +from psycopg_pool import AsyncConnectionPool +from pydantic import BaseModel, Field, ConfigDict + +# Configuration +DATABASE_URL = os.environ.get("DATABASE_URL", "postgresql://messenger:messenger@db:5432/messenger") +REDIS_URL = os.environ.get("REDIS_URL", "redis://redis:6379/0") +SESSION_TTL = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + +# Global state for pool and redis +pool: Optional[AsyncConnectionPool] = None +redis_client: Optional[redis.Redis] = None + + +# Pydantic Models (Contract Lab 2) +class UserCreate(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) + +class UserOut(BaseModel): + id: str + username: str + display_name: str + created_at: str + +class ChatCreate(BaseModel): + model_config = ConfigDict(extra='forbid') + title: str = Field(..., min_length=1, max_length=100) + member_ids: List[str] = Field(..., min_length=1, max_length=100) + +class ChatOut(BaseModel): + id: str + title: str + member_ids: List[str] + created_at: str + +class MessageCreate(BaseModel): + model_config = ConfigDict(extra='forbid') + text: str = Field(..., min_length=1, max_length=4000) + +class MessageOut(BaseModel): + id: str + chat_id: str + sender_id: str + text: str + created_at: str + +class PageResponse(BaseModel): + items: List[dict] + next_cursor: Optional[str] + +class SessionResponse(BaseModel): + token: str + token_type: str = "Bearer" + expires_at: str + user: UserOut + + +# Security helpers +def hash_password(password: str) -> str: + """scrypt KDF with random salt.""" + salt = secrets.token_bytes(16) + # n=16384, r=8, p=1 is a good baseline for scrypt + key = hashlib.scrypt(password.encode('utf-8'), salt=salt, n=16384, r=8, p=1, dklen=64) + return f"{salt.hex()}${key.hex()}" + +def verify_password(password: str, stored: str) -> bool: + try: + salt_hex, key_hex = stored.split("$") + salt = bytes.fromhex(salt_hex) + expected_key = bytes.fromhex(key_hex) + actual_key = hashlib.scrypt(password.encode('utf-8'), salt=salt, n=16384, r=8, p=1, dklen=64) + return secrets.compare_digest(actual_key, expected_key) + except Exception: + return False + +def generate_token() -> str: + return secrets.token_urlsafe(48) + +def encode_cursor(scope: str, created_at: str) -> str: + payload = json.dumps({"s": scope, "t": created_at}, separators=(",", ":")) + return base64.urlsafe_b64encode(payload.encode("utf-8")).decode("ascii").rstrip("=") + +def decode_cursor(cursor: str, expected_scope: str) -> Optional[str]: + try: + pad = "=" * (-len(cursor) % 4) + data = json.loads(base64.urlsafe_b64decode(cursor + pad)) + if data.get("s") == expected_scope and isinstance(data.get("t"), str): + return data["t"] + except Exception: + pass + return None + + +# FastAPI Lifespan (Startup / Shutdown) +@asynccontextmanager +async def lifespan(app: FastAPI): + global pool, redis_client + # Initialize DB pool + pool = AsyncConnectionPool(DATABASE_URL, min_size=2, max_size=10, open=False) + await pool.open() + # Initialize Redis + redis_client = redis.from_url(REDIS_URL, decode_responses=True) + + # Check connections + async with pool.connection() as conn: + await conn.execute("SELECT 1") + await redis_client.ping() + + yield + + # Cleanup + await pool.close() + await redis_client.aclose() + +app = FastAPI(lifespan=lifespan) + + +@app.middleware("http") +async def add_instance_id(request: Request, call_next): + response = await call_next(request) + # Уникальный идентификатор текущего процесса/контейнера + response.headers["X-Instance-Id"] = os.environ.get("HOSTNAME", socket.gethostname()) + return response + +# Middleware & Error Handling +@app.middleware("http") +async def add_request_id(request: Request, call_next): + request.state.request_id = uuid.uuid4().hex + response = await call_next(request) + response.headers["X-Request-Id"] = request.state.request_id + return response + +@app.exception_handler(HTTPException) +async def custom_http_exception_handler(request: Request, exc: HTTPException): + # Map standard FastAPI detail to contract format + code_map = { + 400: "invalid_request", 401: "unauthorized", 404: "not_found", + 409: "conflict", 503: "unavailable", 500: "internal_error" + } + error_code = code_map.get(exc.status_code, "internal_error") + + payload = { + "error": { + "code": error_code, + "message": str(exc.detail), + "request_id": getattr(request.state, "request_id", "unknown") + } + } + + headers = {} + # Добавляем обязательный заголовок по контракту + if exc.status_code == 401: + if request.url.path == "/api/v1/auth/sessions": + headers["WWW-Authenticate"] = 'Basic realm="messenger", charset="UTF-8"' + else: + headers["WWW-Authenticate"] = 'Bearer realm="messenger"' + + return JSONResponse(status_code=exc.status_code, content=payload, headers=headers) + +@app.exception_handler(RequestValidationError) + + +async def validation_exception_handler(request: Request, exc: RequestValidationError): + payload = { + "error": { + "code": "invalid_request", + "message": "Invalid request parameters", + "request_id": getattr(request.state, "request_id", "unknown") + } + } + return JSONResponse(status_code=400, content=payload) + + +# Dependencies +async def get_current_user(request: Request, authorization: Optional[str] = Header(None)) -> dict: + if not authorization or not authorization.startswith("Bearer "): + raise HTTPException(401, "Missing or invalid Authorization header") + + token = authorization[7:] + user_id = await redis_client.get(f"session:{token}") + if not user_id: + raise HTTPException(401, "Session expired or invalid") + + async with pool.connection() as conn: + async with conn.cursor() as cur: + await cur.execute( + "SELECT id::text, username, display_name, to_char(created_at, 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"') FROM users WHERE id = %s", + (user_id,) + ) + row = await cur.fetchone() + if not row: + raise HTTPException(401, "User no longer exists") + return {"id": row[0], "username": row[1], "display_name": row[2], "created_at": row[3]} + + +# Health Endpoints +@app.get("/health/live") +async def health_live(): + return {"status": "ok"} + +@app.get("/health/ready") +async def health_ready(): + try: + async with pool.connection() as conn: + await conn.execute("SELECT 1") + await redis_client.ping() + return {"status": "ok"} + except Exception: + raise HTTPException(503, "Dependencies unavailable") + + +# Auth & Users +@app.post("/api/v1/users", status_code=201, response_model=UserOut) +async def create_user(body: UserCreate): + pwd_hash = hash_password(body.password) + async with pool.connection() as conn: + try: + async with conn.cursor() as cur: + await cur.execute( + "INSERT INTO users (username, display_name, password_hash) " + "VALUES (%s, %s, %s) " + "RETURNING id::text, username, display_name, to_char(created_at, 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"')", + (body.username, body.display_name, pwd_hash) + ) + row = await cur.fetchone() + await conn.commit() + return {"id": row[0], "username": row[1], "display_name": row[2], "created_at": row[3]} + except Exception as e: + await conn.rollback() + if "unique" in str(e).lower(): + raise HTTPException(409, "Username already taken") + raise HTTPException(400, "Invalid user data") + +@app.post("/api/v1/auth/sessions", status_code=201, response_model=SessionResponse) +async def login(authorization: Optional[str] = Header(None)): + if not authorization or not authorization.startswith("Basic "): + raise HTTPException(401, "Basic authentication required") + + try: + creds = base64.b64decode(authorization[6:]).decode('utf-8').split(":", 1) + if len(creds) != 2: + raise ValueError() + username, password = creds + except Exception: + raise HTTPException(401, "Invalid credentials") + + async with pool.connection() as conn: + async with conn.cursor() as cur: + await cur.execute( + "SELECT id::text, password_hash, username, display_name, to_char(created_at, 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"') FROM users WHERE username = %s", + (username,) + ) + row = await cur.fetchone() + + if not row or not verify_password(password, row[1]): + raise HTTPException(401, "Invalid credentials") + + token = generate_token() + await redis_client.setex(f"session:{token}", SESSION_TTL, row[0]) + + expires = (dt.datetime.now(dt.timezone.utc) + dt.timedelta(seconds=SESSION_TTL)).strftime("%Y-%m-%dT%H:%M:%S.%fZ") + + return { + "token": token, + "token_type": "Bearer", + "expires_at": expires, + "user": {"id": row[0], "username": row[2], "display_name": row[3], "created_at": row[4]} + } + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def logout(authorization: Optional[str] = Header(None)): + if not authorization or not authorization.startswith("Bearer "): + raise HTTPException(401, "Missing Authorization header") + token = authorization[7:] + + # Удаляем сессию из Redis + deleted = await redis_client.delete(f"session:{token}") + if not deleted: + raise HTTPException(401, "Session invalid or already logged out") + return Response(status_code=204) + +@app.get("/api/v1/users/me", response_model=UserOut) +async def get_me(user: dict = Depends(get_current_user)): + return user + + +# Chats & Messages +@app.post("/api/v1/chats", status_code=201, response_model=ChatOut) +async def create_chat(body: ChatCreate, user: dict = Depends(get_current_user)): + if user["id"] not in body.member_ids: + raise HTTPException(400, "Caller must be a member of the chat") + + unique_members = list(set(body.member_ids)) + if len(unique_members) != len(body.member_ids): + raise HTTPException(400, "Duplicate member IDs") + + async with pool.connection() as conn: + try: + async with conn.transaction(): + async with conn.cursor() as cur: + # Проверка, что все пользователи существуют + await cur.execute("SELECT id::text FROM users WHERE id = ANY(%s::uuid[])", (unique_members,)) + found_users = {r[0] for r in await cur.fetchall()} + if len(found_users) != len(unique_members): + raise HTTPException(400, "One or more members do not exist") + + # Создаём чат + await cur.execute( + "INSERT INTO chats (title) VALUES (%s) RETURNING id::text, title, to_char(created_at, 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"')", + (body.title,) + ) + chat_row = await cur.fetchone() + chat_id = chat_row[0] + + # Добавляем участников + for uid in unique_members: + await cur.execute("INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", (chat_id, uid)) + + return {"id": chat_id, "title": chat_row[1], "member_ids": unique_members, "created_at": chat_row[2]} + except HTTPException: + raise + except Exception as e: + raise HTTPException(500, "Failed to create chat") + +@app.get("/api/v1/chats") +async def list_chats(limit: int = 50, cursor: Optional[str] = None, user: dict = Depends(get_current_user)): + if not (1 <= limit <= 100): + raise HTTPException(400, "Invalid limit") + + cursor_ts = None + if cursor: + cursor_ts = decode_cursor(cursor, "chats") + if not cursor_ts: + raise HTTPException(400, "Invalid cursor") + + async with pool.connection() as conn: + async with conn.cursor() as cur: + if cursor_ts: + await cur.execute( + "SELECT c.id::text, c.title, to_char(c.created_at, 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"') " + "FROM chats c JOIN chat_members cm ON c.id = cm.chat_id " + "WHERE cm.user_id = %s AND c.created_at > %s " + "ORDER BY c.created_at ASC LIMIT %s", + (user["id"], cursor_ts, limit + 1) + ) + else: + await cur.execute( + "SELECT c.id::text, c.title, to_char(c.created_at, 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"') " + "FROM chats c JOIN chat_members cm ON c.id = cm.chat_id " + "WHERE cm.user_id = %s " + "ORDER BY c.created_at ASC LIMIT %s", + (user["id"], limit + 1) + ) + rows = await cur.fetchall() + + # Получаем member_ids для каждого чата + chat_ids = [r[0] for r in rows[:limit]] + members_map = {} + if chat_ids: + await cur.execute("SELECT chat_id::text, user_id::text FROM chat_members WHERE chat_id = ANY(%s::uuid[])", (chat_ids,)) + for cid, uid in await cur.fetchall(): + members_map.setdefault(cid, []).append(uid) + + items = [] + next_cursor = None + for r in rows[:limit]: + items.append({"id": r[0], "title": r[1], "created_at": r[2], "member_ids": members_map.get(r[0], [])}) + + if len(rows) > limit: + next_cursor = encode_cursor("chats", items[-1]["created_at"]) + + return {"items": items, "next_cursor": next_cursor} + +@app.get("/api/v1/chats/{chat_id}") +async def get_chat(chat_id: str, user: dict = Depends(get_current_user)): + async with pool.connection() as conn: + async with conn.cursor() as cur: + # Проверка членства + await cur.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user["id"])) + if not await cur.fetchone(): + raise HTTPException(404, "Chat not found") + + await cur.execute( + "SELECT id::text, title, to_char(created_at, 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"') FROM chats WHERE id = %s", + (chat_id,) + ) + chat = await cur.fetchone() + + await cur.execute("SELECT user_id::text FROM chat_members WHERE chat_id = %s", (chat_id,)) + members = [r[0] for r in await cur.fetchall()] + + return {"id": chat[0], "title": chat[1], "created_at": chat[2], "member_ids": members} + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +async def create_message( + chat_id: str, + body: MessageCreate, + user: dict = Depends(get_current_user), + idempotency_key: str = Header(None, alias="Idempotency-Key") +): + if not idempotency_key: + raise HTTPException(400, "Idempotency-Key is required") + + # Хеш тела запроса (чтобы отличать одинаковые запросы от разных) + req_hash = hashlib.sha256(body.text.encode('utf-8')).hexdigest() + new_msg_id = str(uuid.uuid4()) + + async with pool.connection() as conn: + async with conn.transaction(): + async with conn.cursor() as cur: + # 1. Проверяем доступ к чату + await cur.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user["id"])) + if not await cur.fetchone(): + raise HTTPException(404, "Chat not found") + + # 2. Пытаемся занять ключ (если ключ есть, ничего не делаем) + await cur.execute( + "INSERT INTO idempotency_keys (key, user_id, request_hash, message_id) " + "VALUES (%s, %s, %s, %s) ON CONFLICT DO NOTHING", + (idempotency_key, user["id"], req_hash, new_msg_id) + ) + + # 3. Проверяем, мы ли заняли ключ (rowcount == 1) + if cur.rowcount == 1: + # Ключ наш -> создаем сообщение + await cur.execute( + "INSERT INTO messages (id, chat_id, sender_id, text) " + "VALUES (%s, %s, %s, %s) " + "RETURNING id::text, chat_id::text, sender_id::text, text, to_char(created_at, 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"')", + (new_msg_id, chat_id, user["id"], body.text) + ) + row = await cur.fetchone() + return {"id": row[0], "chat_id": row[1], "sender_id": row[2], "text": row[3], "created_at": row[4]} + else: + # Ключ уже занят -> читаем старый + await cur.execute( + "SELECT request_hash, message_id FROM idempotency_keys WHERE key = %s AND user_id = %s", + (idempotency_key, user["id"]) + ) + key_row = await cur.fetchone() + # Если текст сообщения отличается, а ключ тот же -> 409 Conflict + if key_row[0] != req_hash: + raise HTTPException(409, "Idempotency key reused with different body") + + # Возвращаем ранее созданное сообщение + await cur.execute( + "SELECT id::text, chat_id::text, sender_id::text, text, to_char(created_at, 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"') " + "FROM messages WHERE id = %s", + (key_row[1],) + ) + row = await cur.fetchone() + return {"id": row[0], "chat_id": row[1], "sender_id": row[2], "text": row[3], "created_at": row[4]} + + +@app.get("/api/v1/chats/{chat_id}/messages", response_model=PageResponse) +async def list_messages(chat_id: str, limit: int = 50, cursor: Optional[str] = None, user: dict = Depends(get_current_user)): + if not (1 <= limit <= 100): + raise HTTPException(400, "Invalid limit") + + scope = f"chat:{chat_id}" + cursor_ts = None + if cursor: + cursor_ts = decode_cursor(cursor, scope) + if not cursor_ts: + raise HTTPException(400, "Invalid cursor") + + async with pool.connection() as conn: + async with conn.cursor() as cur: + await cur.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user["id"])) + if not await cur.fetchone(): + raise HTTPException(404, "Chat not found") + + query = ( + "SELECT id::text, chat_id::text, sender_id::text, text, to_char(created_at, 'YYYY-MM-DD\"T\"HH24:MI:SS.US\"Z\"') " + "FROM messages WHERE chat_id = %s " + ) + params = [chat_id] + + if cursor_ts: + query += "AND created_at > %s " + params.append(cursor_ts) + + query += "ORDER BY created_at ASC LIMIT %s" + params.append(limit + 1) + + await cur.execute(query, tuple(params)) + rows = await cur.fetchall() + + items = [] + next_cursor = None + for r in rows[:limit]: + items.append({"id": r[0], "chat_id": r[1], "sender_id": r[2], "text": r[3], "created_at": r[4]}) + + if len(rows) > limit: + next_cursor = encode_cursor(scope, items[-1]["created_at"]) + + return {"items": items, "next_cursor": next_cursor} \ No newline at end of file diff --git a/src/security.py b/src/security.py new file mode 100644 index 00000000..6bbdd78b --- /dev/null +++ b/src/security.py @@ -0,0 +1,16 @@ +import hashlib, os, secrets + +def hash_password(password: str) -> str: + salt = secrets.token_bytes(16) + key = hashlib.scrypt(password.encode(), salt=salt, n=16384, r=8, p=1, dklen=64) + return salt.hex() + "$" + key.hex() + +def verify_password(password: str, stored: str) -> bool: + salt_hex, key_hex = stored.split("$") + salt = bytes.fromhex(salt_hex) + expected = bytes.fromhex(key_hex) + actual = hashlib.scrypt(password.encode(), salt=salt, n=16384, r=8, p=1, dklen=64) + return secrets.compare_digest(actual, expected) + +def generate_token() -> str: + return secrets.token_urlsafe(48) # ~384 бита энтропии \ No newline at end of file diff --git a/tests/failover.py b/tests/failover.py new file mode 100644 index 00000000..1334e58c --- /dev/null +++ b/tests/failover.py @@ -0,0 +1,93 @@ +#!/usr/bin/env python3 +"""Failover test for lab3: hits API concurrently, kills one replica, checks survival.""" +import argparse +import subprocess +import sys +import threading +import time +import uuid + +from client import Client, Failure, run, check + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument('--base-url', default='http://localhost:8080') + ap.add_argument('--action-script', required=True) + args = ap.parse_args() + + c = Client(args.base_url) + alice, bob, eve, chat = c.bootstrap() + path = '/api/v1/chats/' + chat['id'] + + instances = set() + messages = [] + errors = 0 + + # 1. Собираем имена реплик (X-Instance-Id) + for _ in range(10): + r = c.call('GET', '/health/live') + instances.add(r['headers'].get('X-Instance-Id')) + time.sleep(0.05) + + check(len(instances) >= 2, 'Expected at least 2 API replicas, got: ' + str(instances)) + print('Observed replicas:', instances) + + # 2. Запускаем фоновую нагрузку + stop_event = threading.Event() + + def sender(thread_id): + nonlocal errors + local_c = Client(args.base_url, timeout=5) + i = 0 + while not stop_event.is_set(): + key = uuid.uuid4().hex + text = f'msg_{thread_id}_{i}' + try: + r = local_c.message(alice, chat, text, key=key) + messages.append(r['json']['id']) + instances.add(r['headers'].get('X-Instance-Id')) + except Failure: + # Во время отказа запросы могут падать. Повторяем с тем же ключом. + try: + time.sleep(0.1) + r = local_c.message(alice, chat, text, key=key) + messages.append(r['json']['id']) + except Failure: + errors += 1 + i += 1 + time.sleep(0.02) + + threads = [threading.Thread(target=sender, args=(t,)) for t in range(4)] + for t in threads: t.start() + + time.sleep(1) # Даем нагрузке раскрутиться + + # 3. Запускаем скрипт остановки реплики + print(f'Running action script: {args.action_script}') + subprocess.run(args.action_script, shell=True, check=True) + + # 4. Ждем восстановления и останавливаем нагрузку + time.sleep(4) + stop_event.set() + for t in threads: t.join() + + # 5. Проверяем, что история не потерялась и нет дублей + history_ids = [] + cursor = None + while True: + q = path + '/messages?limit=100' + if cursor: q += '&cursor=' + cursor + page = c.call('GET', q, actor=alice, schema='MessagePage')['json'] + for m in page['items']: + history_ids.append(m['id']) + cursor = page['next_cursor'] + if not cursor: break + + check(len(set(history_ids)) == len(history_ids), 'Duplicate messages found!') + check(len(messages) > 0, 'No messages were successfully sent') + + print(f'Success! Replicas used: {len(instances)}, Messages sent: {len(messages)}, Network errors (retried safely): {errors}') + print('PASS: failover verified') + +if __name__ == '__main__': + run(main) \ No newline at end of file diff --git a/tests/load_fast.py b/tests/load_fast.py new file mode 100644 index 00000000..5f1bc06e --- /dev/null +++ b/tests/load_fast.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python3 +import http.client +import json +import threading +import time +import uuid + +BASE_URL = "127.0.0.1" +PORT = 8080 + +def worker(token, chat_id, duration, stats): + # Каждый поток открывает ОДНО соединение и шлет по нему много запросов + conn = http.client.HTTPConnection(BASE_URL, PORT) + headers = { + "Authorization": f"Bearer {token}", + "Content-Type": "application/json" + } + end_time = time.time() + duration + while time.time() < end_time: + headers["Idempotency-Key"] = uuid.uuid4().hex + body = json.dumps({"text": "load-test"}) + try: + conn.request("POST", f"/api/v1/chats/{chat_id}/messages", body=body, headers=headers) + resp = conn.getresponse() + resp.read() + if resp.status == 201: + stats['success'] += 1 + else: + stats['error'] += 1 + except Exception: + stats['error'] += 1 + conn = http.client.HTTPConnection(BASE_URL, PORT) # Переподключение при ошибке + +def main(): + # 1. Подготовка (регистрация, логин, создание чата) + # Для простоты используем готовый tests/client.py + import sys + from pathlib import Path + sys.path.insert(0, str(Path(__file__).resolve().parent)) + from client import Client + + c = Client("http://127.0.0.1:8080") + alice, bob, eve, chat = c.bootstrap() + token = alice['token'] + + # 2. Запуск нагрузки + duration = 20 + num_threads = 20 + stats = {'success': 0, 'error': 0} + threads = [threading.Thread(target=worker, args=(token, chat['id'], duration, stats)) for _ in range(num_threads)] + + print(f"Starting load: {num_threads} threads for {duration}s...") + start_time = time.time() + for t in threads: t.start() + for t in threads: t.join() + elapsed = time.time() - start_time + + rps = stats['success'] / elapsed + print(f"RESULT: RPS={rps:.2f}, Success={stats['success']}, Errors={stats['error']}") + +if __name__ == '__main__': + main() \ No newline at end of file