ЛР3 БВТ2302 Никитина на 5 #92

Closed
Julia_Nikitina wants to merge 1 commits from Julia_Nikitina/mtusi2026lab3:solution/bvt2302-nikitina into main
21 changed files with 1138 additions and 48 deletions
+10
View File
@@ -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"]
+34 -16
View File
@@ -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)"
+76 -22
View File
@@ -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 <url> && 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-реплик (вертикальное масштабирование), либо оптимизировать код приложения (например, перейти на асинхронный драйвер БД с меньшими накладными расходами).
+59
View File
@@ -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:
+18
View File
@@ -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%
+34
View File
@@ -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);
+8
View File
@@ -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)
);
+25
View File
@@ -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;
}
}
}
+6
View File
@@ -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
+41
View File
@@ -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;
+4
View File
@@ -0,0 +1,4 @@
@echo off
echo Restarting API, PostgreSQL, and Redis (volumes preserved)...
docker compose down
docker compose up -d
-10
View File
@@ -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
+3
View File
@@ -0,0 +1,3 @@
Write-Host "Restarting the whole stack..."
docker compose down
docker compose up -d --scale api=2
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
echo "Restarting the whole stack..."
docker compose down
docker compose up -d --scale api=2
+79
View File
@@ -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"
+43
View File
@@ -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
+8
View File
@@ -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
+515
View File
@@ -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}
+16
View File
@@ -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 бита энтропии
+93
View File
@@ -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)
+62
View File
@@ -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()