ЛР3 БВТ2302 Никитина на 5 #92
+10
@@ -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"]
|
||||
@@ -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)"
|
||||
@@ -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-реплик (вертикальное масштабирование), либо оптимизировать код приложения (например, перейти на асинхронный драйвер БД с меньшими накладными расходами).
|
||||
@@ -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:
|
||||
@@ -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%
|
||||
@@ -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);
|
||||
@@ -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)
|
||||
);
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
@@ -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;
|
||||
@@ -0,0 +1,4 @@
|
||||
@echo off
|
||||
echo Restarting API, PostgreSQL, and Redis (volumes preserved)...
|
||||
docker compose down
|
||||
docker compose up -d
|
||||
@@ -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
|
||||
@@ -0,0 +1,3 @@
|
||||
Write-Host "Restarting the whole stack..."
|
||||
docker compose down
|
||||
docker compose up -d --scale api=2
|
||||
@@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
echo "Restarting the whole stack..."
|
||||
docker compose down
|
||||
docker compose up -d --scale api=2
|
||||
@@ -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"
|
||||
@@ -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
|
||||
@@ -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
@@ -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}
|
||||
@@ -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 бита энтропии
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user