From 117a7783aaf532e085bd9df4b5b19a2a799802a2 Mon Sep 17 00:00:00 2001 From: Tutuxaaa Date: Fri, 30 Oct 2026 16:39:32 +0300 Subject: [PATCH] lab3 --- .env.example | 15 +- Dockerfile | 28 +++ Makefile | 5 +- REPORT.md | 118 +++++++-- compose.yaml | 107 ++++++++ evidence/RUN_ME.md | 9 + migrations/01_initial.sql | 30 +++ migrations/02_chat_order.sql | 1 + migrations/03_idempotency.sql | 11 + nginx/default.conf | 25 ++ nginx/nginx.conf | 7 + requirements.txt | 18 ++ scripts/restart.cmd | 6 + scripts/restart.sh | 5 + scripts/rolling-update.cmd | 6 + scripts/rolling-update.sh | 5 + scripts/start-one.sh | 7 + scripts/stop-one.cmd | 6 + scripts/stop-one.sh | 8 + scripts/test_parallel.py | 42 ++++ src/__init__.py | 0 src/db.py | 29 +++ src/errors.py | 14 ++ src/main.py | 445 ++++++++++++++++++++++++++++++++++ src/migrate.py | 36 +++ src/pagination.py | 47 ++++ src/run.py | 23 ++ src/sessions.py | 33 +++ 28 files changed, 1049 insertions(+), 37 deletions(-) create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 evidence/RUN_ME.md create mode 100644 migrations/01_initial.sql create mode 100644 migrations/02_chat_order.sql create mode 100644 migrations/03_idempotency.sql create mode 100644 nginx/default.conf create mode 100644 nginx/nginx.conf create mode 100644 requirements.txt create mode 100644 scripts/restart.cmd create mode 100644 scripts/restart.sh create mode 100644 scripts/rolling-update.cmd create mode 100644 scripts/rolling-update.sh create mode 100644 scripts/start-one.sh create mode 100644 scripts/stop-one.cmd create mode 100644 scripts/stop-one.sh create mode 100644 scripts/test_parallel.py create mode 100644 src/__init__.py create mode 100644 src/db.py create mode 100644 src/errors.py create mode 100644 src/main.py create mode 100644 src/migrate.py create mode 100644 src/pagination.py create mode 100644 src/run.py create mode 100644 src/sessions.py diff --git a/.env.example b/.env.example index d32b9be0..70e28112 100644 --- a/.env.example +++ b/.env.example @@ -1,13 +1,4 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. -APP_HOST=0.0.0.0 -APP_PORT=8080 -APP_ENV=lab +POSTGRES_DB=messenger +POSTGRES_USER=messenger +POSTGRES_PASSWORD=change-this-for-local-demo SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url -API_REPLICAS=2 -IDEMPOTENCY_TTL_SECONDS=86400 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..14fc6243 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,28 @@ +FROM python:3.14.8-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 \ + APP_ENV=lab + +WORKDIR /app +COPY requirements.txt ./ +RUN python -m pip install --no-cache-dir -r requirements.txt +RUN groupadd --gid 10001 appuser \ + && useradd --uid 10001 --gid appuser --no-create-home --shell /usr/sbin/nologin appuser + +COPY src ./src +COPY migrations ./migrations +COPY tests ./tests +COPY scripts ./scripts +COPY contracts ./contracts +COPY lab.json ./ + +USER 10001:10001 +EXPOSE 8080 +STOPSIGNAL SIGTERM +HEALTHCHECK --interval=5s --timeout=3s --start-period=5s --retries=3 \ + CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:'+os.getenv('APP_PORT','8080')+'/health/ready', timeout=2).close()"] + +CMD ["python", "-m", "src.run"] diff --git a/Makefile b/Makefile index 5d86d171..83da1fd0 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +.PHONY: help check validate test load test-parallel test-persistence test-failover help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -18,6 +18,9 @@ validate: test: $(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS) +test-parallel: + $(PYTHON) scripts/test_parallel.py + load: $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) diff --git a/REPORT.md b/REPORT.md index c2679005..612dd636 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,107 @@ -# Отчёт — лабораторная 3 +# Лабораторная работа №3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +Группа БВТ2302, Рестеу Д. А. +Цель: балансировка API и проверка работы при отказе одной реплики. +Планируемая оценка: 4. -## Запуск из чистого clone +## Что сделал -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Взял REST API из второй лабораторной. PostgreSQL хранит пользователей, чаты и сообщения, а Redis — сессии. Эти данные не лежат в памяти отдельного API, поэтому оба экземпляра работают с одной базой и узнают один токен. -## Архитектура и решения +В `compose.yaml` добавил два сервиса `api1` и `api2`, а перед ними Nginx (`lb`). Снаружи опубликован только `127.0.0.1:8080`, запросы к репликам идут через внутреннюю сеть Docker. В каждом ответе API есть `X-Instance-Id`: `api1` или `api2`. -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Добавил миграцию `03_idempotency.sql` с таблицей `message_requests`. Отправка сообщения теперь требует `Idempotency-Key`. Первая транзакция сохраняет сообщение и информацию о ключе вместе. Повтор с тем же ключом и текстом возвращает исходное сообщение, а повтор с другим текстом возвращает 409. Уникальный первичный ключ в PostgreSQL не позволяет параллельным запросам создать два сообщения. Срок действия ключа — 24 часа. -## Доказательства критериев +Для проверки готовности оставил `/health/live` и `/health/ready`. Второй endpoint проверяет PostgreSQL и Redis. В Nginx настроил DNS-переопределение адресов, таймауты и пассивное исключение недоступного API. У контейнеров API лимит 0,5 CPU и 256 MiB памяти. Отдельный `migrate` применяет SQL до запуска реплик. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +## Запуск -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Нужны Docker Desktop с Compose и Python 3.9+ для проверок. Команды выполнять из корня лабораторной. -## Эксперименты и отказы +Для PowerShell: -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +```powershell +Copy-Item .env.example .env +# В .env заменяю POSTGRES_PASSWORD на свой локальный пароль -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +docker compose --env-file .env up -d --build --wait +docker compose --env-file .env ps +python tests/smoke.py --base-url http://localhost:8080 +python scripts/test_parallel.py +``` -## Ограничения и следующие шаги +Swagger: http://localhost:8080/docs. Все запросы к API в тестах идут только через Nginx. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Проверка отказа прямо в PowerShell (без `make` и WSL): + +```powershell +python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd +# Вернуть обе реплики +docker compose up -d --wait api1 api2 +python tests/resilience.py --mode persistence --action-script scripts/restart.cmd +``` + +Для Linux/WSL с `make`: + +```sh +cp .env.example .env +# Изменить пароль в .env +chmod +x scripts/*.sh +make check +make test +make test-parallel +``` + +При необходимости перед запуском проверяю настройки командой `docker compose --env-file .env config --quiet`. + +## Проверка отказа + +Сначала запустить `make test` и `make test-parallel`. Затем в Linux/WSL: + +```sh +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +# После теста посмотреть реально остановленный контейнер: +docker compose ps -a +# Восстановить обе реплики: +docker compose up -d --wait api1 api2 +# Повторить failover: тест сам выберет инстанс первого сообщения +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +# Вернуть реплики +docker compose up -d --wait api1 api2 +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` + +Скрипт `stop-one.sh` читает `TARGET_INSTANCE_ID` из теста и останавливает именно выбранную реплику. Если реплика уже остановлена, перед следующим запуском её нужно поднять. + +Для поочередного обновления после сборки образа: + +```sh +docker compose build api1 api2 +./scripts/rolling-update.sh +``` + +На время этой операции отдельно запускаю `python tests/load.py --duration 30 --concurrency 4 --output evidence/rolling-load.json`, после чего просматриваю сохранённые показатели. На Windows для обновления использую `scripts/rolling-update.cmd`. Важно: для подтверждения обновления тест нагрузки должен идти одновременно со скриптом обновления. + +## Проверки и доказательства + +| Проверка | Команда | Что должно получиться | +| --- | --- | --- | +| Структура | `make check` | PASS | +| Запуск и API | `make test` | PASS, один полный пользовательский сценарий | +| Две реплики | повтор `GET /health/live` | ответы с разными `X-Instance-Id` | +| Одновременный повтор POST | `make test-parallel` | один ID сообщения в 12 ответах | +| Отказ реплики | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | запись продолжается через другую реплику | +| Сохранение данных | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | тот же токен и сообщения после перезапуска | +| Нагрузка | `make load` | фактические RPS, ошибки, p50/p95/p99 | + +Реальные результаты `test-failover` и `load` нужно записать после запуска стенда на своём компьютере. До запуска Docker эти проверки не считаю выполненными. + +## Ограничения + +Решение выдерживает остановку одного API, но не остановку Nginx, Redis, PostgreSQL или всего Docker-хоста — это оставшиеся единые точки отказа. Nginx проверяет недоступность через ошибки и таймауты запросов, а не активным опросом каждой реплики. Настроены `fail_timeout=2s`, `proxy_connect_timeout=1s`; фактическое восстановление проверяется отдельным failover-тестом. Команда `docker compose down -v` удалит тестовые данные, обычная `docker compose down` — нет. + +## Ссылки + +- https://docs.docker.com/reference/compose-file/services/ +- https://nginx.org/ru/docs/http/ngx_http_upstream_module.html +- https://www.postgresql.org/docs/current/sql-insert.html diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..2bc06214 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,107 @@ +services: + postgres: + image: postgres:17.11-bookworm + environment: + POSTGRES_DB: ${POSTGRES_DB:?Set POSTGRES_DB in .env} + POSTGRES_USER: ${POSTGRES_USER:?Set POSTGRES_USER in .env} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env} + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"] + interval: 5s + timeout: 3s + retries: 10 + cpus: 1.0 + mem_limit: 512m + restart: unless-stopped + + redis: + image: redis:8.2.10-bookworm + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"] + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + cpus: 0.50 + mem_limit: 256m + restart: unless-stopped + + migrate: + build: . + command: ["python", "-m", "src.migrate"] + environment: &db_env + POSTGRES_DB: ${POSTGRES_DB} + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + depends_on: + postgres: + condition: service_healthy + cpus: 0.50 + mem_limit: 256m + restart: "no" + + api1: + build: . + environment: + <<: *db_env + INSTANCE_ID: api1 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + depends_on: &api_depends + postgres: + condition: service_healthy + redis: + condition: service_healthy + migrate: + condition: service_completed_successfully + healthcheck: &api_health + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).close()"] + interval: 3s + timeout: 3s + retries: 3 + start_period: 10s + cpus: 0.50 + mem_limit: 256m + stop_grace_period: 15s + restart: unless-stopped + + api2: + build: . + environment: + <<: *db_env + INSTANCE_ID: api2 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + depends_on: *api_depends + healthcheck: *api_health + cpus: 0.50 + mem_limit: 256m + stop_grace_period: 15s + restart: unless-stopped + + lb: + image: nginx:1.28.0-alpine + cpus: 0.50 + mem_limit: 128m + volumes: + - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro + - ./nginx/default.conf:/etc/nginx/conf.d/default.conf:ro + ports: + - "127.0.0.1:8080:8080" + depends_on: + api1: + condition: service_healthy + api2: + condition: service_healthy + healthcheck: + test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/health/ready"] + interval: 5s + timeout: 3s + retries: 3 + restart: unless-stopped + +volumes: + postgres_data: + redis_data: diff --git a/evidence/RUN_ME.md b/evidence/RUN_ME.md new file mode 100644 index 00000000..6d8db18f --- /dev/null +++ b/evidence/RUN_ME.md @@ -0,0 +1,9 @@ +Результаты экспериментов добавляю после запуска Docker на своём компьютере. + +1. `docker compose ps -a` — какие контейнеры работают. +2. `python tests/load.py --duration 30 --concurrency 4 --output evidence/load.json` +3. `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` — вывод с successful_writes, failed_attempts, first_recovery_seconds. +4. `make test-persistence ACTION_SCRIPT=scripts/restart.sh` — проверка сохранения данных. +5. Отдельный `rolling-update.sh` во время `tests/load.py`. + +Не добавляю туда токены и пароли. diff --git a/migrations/01_initial.sql b/migrations/01_initial.sql new file mode 100644 index 00000000..c26001b5 --- /dev/null +++ b/migrations/01_initial.sql @@ -0,0 +1,30 @@ +CREATE TABLE users ( + id UUID PRIMARY KEY, + username VARCHAR(32) NOT NULL UNIQUE, + display_name VARCHAR(100) NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title VARCHAR(100) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id), + user_id UUID NOT NULL REFERENCES users(id), + PRIMARY KEY (chat_id, user_id) +); + +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id), + sender_id UUID NOT NULL REFERENCES users(id), + text VARCHAR(4000) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id); +CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id); diff --git a/migrations/02_chat_order.sql b/migrations/02_chat_order.sql new file mode 100644 index 00000000..0922abd8 --- /dev/null +++ b/migrations/02_chat_order.sql @@ -0,0 +1 @@ +CREATE INDEX chats_order_idx ON chats (created_at, id); diff --git a/migrations/03_idempotency.sql b/migrations/03_idempotency.sql new file mode 100644 index 00000000..ac3f7681 --- /dev/null +++ b/migrations/03_idempotency.sql @@ -0,0 +1,11 @@ +CREATE TABLE message_requests ( + sender_id UUID NOT NULL REFERENCES users(id), + chat_id UUID NOT NULL REFERENCES chats(id), + request_key VARCHAR(128) NOT NULL, + request_hash CHAR(64) NOT NULL, + message_id UUID REFERENCES messages(id), + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (sender_id, chat_id, request_key) +); + +CREATE INDEX message_requests_created_idx ON message_requests (created_at); diff --git a/nginx/default.conf b/nginx/default.conf new file mode 100644 index 00000000..336d8c25 --- /dev/null +++ b/nginx/default.conf @@ -0,0 +1,25 @@ +upstream api_backends { + zone api_backends 64k; + resolver 127.0.0.11 valid=2s ipv6=off; + server api1:8080 resolve max_fails=1 fail_timeout=2s; + server api2:8080 resolve max_fails=1 fail_timeout=2s; +} + +server { + listen 8080; + server_name _; + + location / { + proxy_pass http://api_backends; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header Connection ""; + proxy_connect_timeout 1s; + proxy_read_timeout 7s; + proxy_send_timeout 7s; + proxy_next_upstream error timeout http_502 http_503 http_504; + proxy_next_upstream_tries 2; + } +} diff --git a/nginx/nginx.conf b/nginx/nginx.conf new file mode 100644 index 00000000..3d9e6a54 --- /dev/null +++ b/nginx/nginx.conf @@ -0,0 +1,7 @@ +worker_processes auto; +events { worker_connections 1024; } +http { + access_log /dev/stdout; + error_log /dev/stderr warn; + include /etc/nginx/conf.d/*.conf; +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..b1807912 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,18 @@ +annotated-doc==0.0.5 +annotated-types==0.8.0 +anyio==4.15.1 +click==8.5.0 +fastapi==0.143.0 +h11==0.16.0 +idna==3.20 +opentelemetry-api==1.45.1 +pydantic==2.14.1 +pydantic_core==2.50.1 +starlette==1.7.0 +typing-inspection==0.4.4 +typing_extensions==4.16.0 +uvicorn==0.54.0 +psycopg[binary]==3.3.6 +psycopg-pool==3.3.3 +argon2-cffi==25.1.0 +redis==8.1.0 diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..8e69eb7e --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,6 @@ +@echo off +cd /d "%~dp0.." +docker compose --env-file .env stop lb api1 api2 redis postgres +if errorlevel 1 exit /b 1 +docker compose --env-file .env up -d --wait +exit /b %errorlevel% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..190d421c --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env stop lb api1 api2 redis postgres +docker compose --env-file .env up -d --wait diff --git a/scripts/rolling-update.cmd b/scripts/rolling-update.cmd new file mode 100644 index 00000000..c1d13213 --- /dev/null +++ b/scripts/rolling-update.cmd @@ -0,0 +1,6 @@ +@echo off +cd /d "%~dp0.." +docker compose --env-file .env up -d --no-deps --force-recreate --wait api1 +if errorlevel 1 exit /b 1 +docker compose --env-file .env up -d --no-deps --force-recreate --wait api2 +exit /b %errorlevel% diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100644 index 00000000..f969fe61 --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env up -d --no-deps --force-recreate --wait api1 +docker compose --env-file .env up -d --no-deps --force-recreate --wait api2 diff --git a/scripts/start-one.sh b/scripts/start-one.sh new file mode 100644 index 00000000..0a4f4b75 --- /dev/null +++ b/scripts/start-one.sh @@ -0,0 +1,7 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +case "${1:-api1}" in + api1|api2) docker compose --env-file .env up -d "$1" ;; + *) echo "Usage: scripts/start-one.sh api1|api2" >&2; exit 2 ;; +esac diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 00000000..876261c5 --- /dev/null +++ b/scripts/stop-one.cmd @@ -0,0 +1,6 @@ +@echo off +cd /d "%~dp0.." +if "%TARGET_INSTANCE_ID%"=="" set "TARGET_INSTANCE_ID=api1" +if not "%TARGET_INSTANCE_ID%"=="api1" if not "%TARGET_INSTANCE_ID%"=="api2" exit /b 2 +docker compose --env-file .env stop %TARGET_INSTANCE_ID% +exit /b %errorlevel% diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..3ca4c1a0 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,8 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +case "${TARGET_INSTANCE_ID:-api1}" in + api1|api2) target="${TARGET_INSTANCE_ID:-api1}" ;; + *) echo "Unknown API replica" >&2; exit 2 ;; +esac +docker compose --env-file .env stop "$target" diff --git a/scripts/test_parallel.py b/scripts/test_parallel.py new file mode 100644 index 00000000..fd34a019 --- /dev/null +++ b/scripts/test_parallel.py @@ -0,0 +1,42 @@ +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path +import sys +import threading +from uuid import uuid4 + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests")) +from client import Client, check + + +def main(): + client = Client() + alice, _, _, chat = client.bootstrap() + key = uuid4().hex + path = "/api/v1/chats/" + chat["id"] + "/messages" + text = "Проверка одновременного повтора " + key + barrier = threading.Barrier(12) + + def send(_): + local = Client(timeout=10) + barrier.wait(timeout=10) + response = local.message(alice, chat, text, key=key) + return response["json"], response["headers"]["X-Instance-Id"] + + with ThreadPoolExecutor(max_workers=12) as workers: + results = list(workers.map(send, range(12))) + + ids = {message["id"] for message, _ in results} + instances = {instance for _, instance in results} + check(len(ids) == 1, "Повтор создал несколько сообщений") + check(len(instances) == 2, "Не удалось проверить обе реплики") + check(all(result[0] == results[0][0] for result in results), "Ответы различаются") + client.call("POST", path, 409, actor=alice, body={"text": "Другой текст"}, + headers={"Idempotency-Key": key}) + page = client.call("GET", path + "?limit=100", actor=alice, schema="MessagePage")["json"] + check(sum(item["id"] in ids for item in page["items"]) == 1, + "В истории найден дубль сообщения") + print("PASS: 12 параллельных запросов; 2 реплики; 1 сообщение; повтор с другим текстом — 409") + + +if __name__ == "__main__": + main() diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/db.py b/src/db.py new file mode 100644 index 00000000..fbb7bde3 --- /dev/null +++ b/src/db.py @@ -0,0 +1,29 @@ +import os + +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool + + +def connection_kwargs(): + return { + "host": os.getenv("POSTGRES_HOST", "postgres"), + "port": int(os.getenv("POSTGRES_PORT", "5432")), + "dbname": os.environ["POSTGRES_DB"], + "user": os.environ["POSTGRES_USER"], + "password": os.environ["POSTGRES_PASSWORD"], + "connect_timeout": 5, + "options": "-c statement_timeout=5000 -c lock_timeout=3000", + "autocommit": True, + "row_factory": dict_row, + } + + +pool = ConnectionPool( + kwargs=connection_kwargs(), + min_size=1, + max_size=5, + max_waiting=20, + timeout=3, + check=ConnectionPool.check_connection, + open=False, +) diff --git a/src/errors.py b/src/errors.py new file mode 100644 index 00000000..73e36a37 --- /dev/null +++ b/src/errors.py @@ -0,0 +1,14 @@ +class ApiError(Exception): + def __init__(self, status, code, message): + super().__init__(message) + self.status = status + self.code = code + self.message = message + + +def invalid(message="Неверный запрос"): + raise ApiError(400, "invalid_request", message) + + +def unauthorized(): + raise ApiError(401, "unauthorized", "Неверные данные авторизации") diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..4215096d --- /dev/null +++ b/src/main.py @@ -0,0 +1,445 @@ +import base64 +import binascii +import hashlib +import json +import os +import logging +import re +import time +from contextlib import asynccontextmanager +from datetime import datetime, timezone +from uuid import UUID, uuid4 + +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError +from fastapi import FastAPI, Header, Query, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse, Response +from psycopg import InterfaceError, OperationalError +from psycopg.errors import ForeignKeyViolation, UniqueViolation +from pydantic import BaseModel, ConfigDict, Field, field_validator +from redis.exceptions import RedisError +from starlette.concurrency import run_in_threadpool +from starlette.exceptions import HTTPException as StarletteHTTPException + +from src.db import pool +from src.errors import ApiError, invalid, unauthorized +from src.pagination import encode_cursor, parse_page +from src.sessions import issue_session, redis_client + + +log = logging.getLogger("messenger") +password_hasher = PasswordHasher() +INSTANCE_ID = os.getenv("INSTANCE_ID", uuid4().hex) +ready = False + + +def parse_uuid(value): + try: + return UUID(value) + except (ValueError, TypeError, AttributeError): + invalid("Некорректный UUID") + + +def row_response(row): + result = {} + for key, value in row.items(): + if isinstance(value, UUID): + value = str(value) + elif isinstance(value, datetime): + value = value.astimezone(timezone.utc).isoformat( + timespec="microseconds" + ).replace("+00:00", "Z") + elif key == "member_ids": + value = [str(member) for member in value] + result[key] = value + return result + + +class InputModel(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + + @field_validator("*", check_fields=False) + @classmethod + def reject_blank(cls, value): + if isinstance(value, str) and not value.strip(): + raise ValueError("Строка не должна быть пустой") + return value + + @field_validator("display_name", "title", "text", check_fields=False) + @classmethod + def reject_nul(cls, value): + if "\u0000" in value: + raise ValueError("Нулевой символ недопустим в текстовом поле") + return value + + +class CreateUser(InputModel): + username: str = Field(min_length=3, max_length=32) + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + @field_validator("username") + @classmethod + def validate_username(cls, value): + if re.fullmatch(r"[a-z0-9_]{3,32}", value) is None: + raise ValueError("Некорректный username") + return value + + +class CreateChat(InputModel): + title: str = Field(min_length=1, max_length=100) + member_ids: list[str] = Field(min_length=1, max_length=100) + + +class CreateMessage(InputModel): + text: str = Field(min_length=1, max_length=4000) + + +def bearer_token(value): + scheme, _, token = (value or "").partition(" ") + if scheme.lower() != "bearer" or not token: + unauthorized() + return token + + +def current_user(value): + token = bearer_token(value) + user_id = redis_client.get("session:" + token) + if user_id is None: + unauthorized() + with pool.connection() as conn: + user = conn.execute( + "SELECT id, username, display_name, created_at FROM users WHERE id = %s", + (UUID(user_id),), + ).fetchone() + if user is None: + unauthorized() + return row_response(user) + + +@asynccontextmanager +async def lifespan(app): + global ready + try: + await run_in_threadpool(pool.open, wait=True, timeout=10) + await run_in_threadpool(redis_client.ping) + ready = True + log.info("startup ready=true") + yield + finally: + ready = False + redis_client.close() + pool.close() + log.info("shutdown complete") + + +app = FastAPI(title="Lab 3 Messenger", lifespan=lifespan) + + +def error_response(request, status, code, message): + request_id = request.state.request_id + headers = {"X-Request-Id": request_id} + if status == 401: + if request.method == "POST" and 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=status, + content={"error": {"code": code, "message": message, "request_id": request_id}}, + headers=headers, + ) + + +@app.exception_handler(ApiError) +async def api_error(request, exc): + return error_response(request, exc.status, exc.code, exc.message) + + +@app.exception_handler(RequestValidationError) +async def validation_error(request, exc): + return error_response(request, 400, "invalid_request", "Некорректные поля или JSON") + + +@app.exception_handler(StarletteHTTPException) +async def http_error(request, exc): + code = "not_found" if exc.status_code == 404 else "invalid_request" + return error_response(request, exc.status_code, code, "Некорректный запрос") + + +@app.middleware("http") +async def process_request(request: Request, call_next): + request.state.request_id = str(uuid4()) + started = time.perf_counter() + try: + is_login = request.method == "POST" and request.url.path == "/api/v1/auth/sessions" + public = request.method == "POST" and request.url.path in ( + "/api/v1/users", "/api/v1/auth/sessions" + ) + if request.url.path.startswith("/api/v1/") and not public: + request.state.user = await run_in_threadpool( + current_user, request.headers.get("Authorization") + ) + if is_login: + if await request.body(): + invalid("Для входа тело запроса должно быть пустым") + elif request.method == "POST" and request.url.path.startswith("/api/v1/"): + media_type = request.headers.get("content-type", "").split(";")[0] + if media_type.strip().lower() != "application/json": + raise ApiError(415, "unsupported_media_type", "Нужен application/json") + response = await call_next(request) + except ApiError as exc: + response = error_response(request, exc.status, exc.code, exc.message) + except (OperationalError, InterfaceError, RedisError): + response = error_response(request, 503, "unavailable", "Хранилище недоступно") + except Exception as exc: + log.error("request_failed type=%s request_id=%s", + type(exc).__name__, request.state.request_id) + response = error_response(request, 500, "internal_error", "Внутренняя ошибка") + response.headers["X-Request-Id"] = request.state.request_id + response.headers["X-Instance-Id"] = INSTANCE_ID + route = request.scope.get("route") + log.info("request method=%s route=%s status=%s duration_ms=%.2f request_id=%s", + request.method, getattr(route, "path", "unmatched"), response.status_code, + (time.perf_counter() - started) * 1000, request.state.request_id) + return response + + +@app.get("/health/live") +def live(): + return {"status": "ok"} + + +@app.get("/health/ready") +def readiness(): + if not ready: + raise ApiError(503, "unavailable", "Приложение не готово") + with pool.connection() as conn: + conn.execute("SELECT 1") + redis_client.ping() + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +def create_user(body: CreateUser): + password_hash = password_hasher.hash(body.password) + try: + with pool.connection() as conn: + user = conn.execute( + "INSERT INTO users (id, username, display_name, password_hash) " + "VALUES (%s, %s, %s, %s) RETURNING id, username, display_name, created_at", + (uuid4(), body.username, body.display_name, password_hash), + ).fetchone() + except UniqueViolation as exc: + if exc.diag.constraint_name == "users_username_key": + raise ApiError(409, "conflict", "Username занят") from None + raise + return row_response(user) + + +@app.post("/api/v1/auth/sessions", status_code=201) +def login(authorization: str | None = Header(default=None)): + scheme, _, encoded = (authorization or "").partition(" ") + if scheme.lower() != "basic" or not encoded: + unauthorized() + try: + decoded = base64.b64decode(encoded, validate=True).decode("utf-8") + username, password = decoded.split(":", 1) + except (ValueError, binascii.Error): + unauthorized() + if re.fullmatch(r"[a-z0-9_]{3,32}", username) is None or not 12 <= len(password) <= 128: + unauthorized() + with pool.connection() as conn: + user = conn.execute( + "SELECT id, username, display_name, password_hash, created_at " + "FROM users WHERE username = %s", (username,), + ).fetchone() + if user is None: + unauthorized() + try: + password_hasher.verify(user["password_hash"], password) + except VerifyMismatchError: + unauthorized() + token, expires_at = issue_session(user["id"]) + del user["password_hash"] + return {"token": token, "token_type": "Bearer", "expires_at": expires_at, + "user": row_response(user)} + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def logout(request: Request): + token = bearer_token(request.headers.get("Authorization")) + redis_client.delete("session:" + token) + return Response(status_code=204) + + +@app.get("/api/v1/users/me") +def get_me(request: Request): + return request.state.user + + +def require_member(conn, chat_id, user_id): + found = conn.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, UUID(user_id)), + ).fetchone() + if found is None: + raise ApiError(404, "not_found", "Чат не найден") + + +CHAT_SELECT = """ + SELECT c.id, c.title, c.created_at, + ARRAY(SELECT user_id FROM chat_members + WHERE chat_id = c.id ORDER BY user_id) AS member_ids + FROM chats c + JOIN chat_members mine ON mine.chat_id = c.id + WHERE mine.user_id = %s +""" + +HISTORY_FIRST_SQL = """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages WHERE chat_id = %s + ORDER BY created_at, id LIMIT %s +""" + +HISTORY_AFTER_SQL = """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages WHERE chat_id = %s AND (created_at, id) > (%s, %s) + ORDER BY created_at, id LIMIT %s +""" + + +def page_response(rows, size, scope): + items = [row_response(row) for row in rows[:size]] + cursor = encode_cursor(scope, items[-1]) if len(rows) > size else None + return {"items": items, "next_cursor": cursor} + + +@app.post("/api/v1/chats", status_code=201) +def create_chat(body: CreateChat, request: Request): + members = sorted(parse_uuid(value) for value in body.member_ids) + if len(members) != len(set(members)): + invalid("Участники повторяются") + if UUID(request.state.user["id"]) not in members: + invalid("Вызывающий должен входить в member_ids") + try: + with pool.connection() as conn: + with conn.transaction(): + chat = conn.execute( + "INSERT INTO chats (id, title) VALUES (%s, %s) " + "RETURNING id, title, created_at", (uuid4(), body.title), + ).fetchone() + with conn.cursor() as cur: + cur.executemany( + "INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", + [(chat["id"], member) for member in members], + ) + except ForeignKeyViolation: + invalid("Неизвестный участник") + chat["member_ids"] = members + return row_response(chat) + + +@app.get("/api/v1/chats") +def list_chats(request: Request, limit: str = Query(default="50"), + cursor: str | None = Query(default=None)): + user_id = request.state.user["id"] + scope = "chats:" + user_id + size, after = parse_page(limit, cursor, scope) + query = CHAT_SELECT + params = [UUID(user_id)] + if after is not None: + query += " AND (c.created_at, c.id) > (%s, %s)" + params.extend(after) + query += " ORDER BY c.created_at, c.id LIMIT %s" + params.append(size + 1) + with pool.connection() as conn: + rows = conn.execute(query, params).fetchall() + return page_response(rows, size, scope) + + +@app.get("/api/v1/chats/{chat_id}") +def get_chat(chat_id: str, request: Request): + with pool.connection() as conn: + chat = conn.execute( + CHAT_SELECT + " AND c.id = %s", + (UUID(request.state.user["id"]), parse_uuid(chat_id)), + ).fetchone() + if chat is None: + raise ApiError(404, "not_found", "Чат не найден") + return row_response(chat) + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def create_message( + chat_id: str, + body: CreateMessage, + request: Request, + idempotency_key: str | None = Header(default=None, alias="Idempotency-Key"), +): + if idempotency_key is None or re.fullmatch(r"[A-Za-z0-9._:-]{1,128}", idempotency_key) is None: + invalid("Некорректный Idempotency-Key") + + chat_uuid = parse_uuid(chat_id) + user_id = UUID(request.state.user["id"]) + digest = hashlib.sha256( + json.dumps({"text": body.text}, ensure_ascii=False, sort_keys=True).encode("utf-8") + ).hexdigest() + + with pool.connection() as conn: + with conn.transaction(): + require_member(conn, chat_uuid, str(user_id)) + conn.execute( + "DELETE FROM message_requests WHERE sender_id = %s AND chat_id = %s " + "AND request_key = %s AND created_at < now() - interval '24 hours'", + (user_id, chat_uuid, idempotency_key), + ) + created = conn.execute( + "INSERT INTO message_requests (sender_id, chat_id, request_key, request_hash) " + "VALUES (%s, %s, %s, %s) ON CONFLICT DO NOTHING RETURNING request_key", + (user_id, chat_uuid, idempotency_key, digest), + ).fetchone() + if created is None: + existing = conn.execute( + "SELECT request_hash, message_id FROM message_requests " + "WHERE sender_id = %s AND chat_id = %s AND request_key = %s", + (user_id, chat_uuid, idempotency_key), + ).fetchone() + if existing is None: + raise ApiError(503, "unavailable", "Повторите запрос") + if existing["request_hash"] != digest: + raise ApiError(409, "conflict", "Ключ уже использован для другого сообщения") + message = conn.execute( + "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE id = %s", + (existing["message_id"],), + ).fetchone() + else: + message = conn.execute( + "INSERT INTO messages (id, chat_id, sender_id, text) " + "VALUES (%s, %s, %s, %s) " + "RETURNING id, chat_id, sender_id, text, created_at", + (uuid4(), chat_uuid, user_id, body.text), + ).fetchone() + conn.execute( + "UPDATE message_requests SET message_id = %s " + "WHERE sender_id = %s AND chat_id = %s AND request_key = %s", + (message["id"], user_id, chat_uuid, idempotency_key), + ) + return row_response(message) + +@app.get("/api/v1/chats/{chat_id}/messages") +def list_messages(chat_id: str, request: Request, limit: str = Query(default="50"), + cursor: str | None = Query(default=None)): + chat_uuid = parse_uuid(chat_id) + scope = "messages:" + str(chat_uuid) + size, after = parse_page(limit, cursor, scope) + with pool.connection() as conn: + require_member(conn, chat_uuid, request.state.user["id"]) + if after is None: + rows = conn.execute(HISTORY_FIRST_SQL, (chat_uuid, size + 1)).fetchall() + else: + rows = conn.execute( + HISTORY_AFTER_SQL, (chat_uuid, after[0], after[1], size + 1) + ).fetchall() + return page_response(rows, size, scope) diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..25bd7d36 --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,36 @@ +from pathlib import Path + +import psycopg + +from src.db import connection_kwargs + + +def main(): + files = sorted((Path(__file__).resolve().parents[1] / "migrations").glob("*.sql")) + if not files: + raise RuntimeError("Миграции не найдены") + with psycopg.connect(**connection_kwargs()) as conn: + conn.execute(""" + CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT now() + ) + """) + for file in files: + applied = False + with conn.transaction(): + conn.execute("SELECT pg_advisory_xact_lock(202602)") + exists = conn.execute( + "SELECT 1 FROM schema_migrations WHERE version = %s", (file.name,) + ).fetchone() + if exists is None: + conn.execute(file.read_text(encoding="utf-8")) + conn.execute( + "INSERT INTO schema_migrations (version) VALUES (%s)", (file.name,) + ) + applied = True + print(("APPLIED " if applied else "SKIP ") + file.name) + + +if __name__ == "__main__": + main() diff --git a/src/pagination.py b/src/pagination.py new file mode 100644 index 00000000..03615854 --- /dev/null +++ b/src/pagination.py @@ -0,0 +1,47 @@ +import base64 +import binascii +import json +import re +from datetime import datetime +from uuid import UUID + +from src.errors import invalid + + +def encode_cursor(scope, item): + data = {"scope": scope, "created_at": item["created_at"], "id": item["id"]} + raw = json.dumps(data, separators=(",", ":")).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") + + +def parse_page(limit, cursor, scope): + if len(limit) > 10 or re.fullmatch(r"[0-9]+", limit) is None: + invalid("limit должен быть целым числом от 1 до 100") + size = int(limit) + if not 1 <= size <= 100: + invalid("limit должен быть от 1 до 100") + if cursor is None: + return size, None + if not cursor or len(cursor) > 2048: + invalid("Некорректный cursor") + try: + raw = base64.b64decode( + cursor + "=" * (-len(cursor) % 4), altchars=b"-_", validate=True + ) + data = json.loads(raw) + if not isinstance(data, dict) or set(data) != {"scope", "created_at", "id"}: + raise ValueError + if data["scope"] != scope or not isinstance(data["created_at"], str): + raise ValueError + if re.fullmatch( + r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]{1,6})?Z", + data["created_at"], + ) is None: + raise ValueError + created_at = datetime.fromisoformat(data["created_at"][:-1] + "+00:00") + if created_at.tzinfo is None: + raise ValueError + item_id = UUID(data["id"]) + except (ValueError, TypeError, AttributeError, binascii.Error): + invalid("Некорректный cursor или cursor от другого ресурса") + return size, (created_at, item_id) diff --git a/src/run.py b/src/run.py new file mode 100644 index 00000000..d01a0b04 --- /dev/null +++ b/src/run.py @@ -0,0 +1,23 @@ +import logging +import os + +import uvicorn + + +if __name__ == "__main__": + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(name)s %(message)s", + ) + logging.getLogger("messenger").info( + "config app_env=%s", os.getenv("APP_ENV", "lab") + ) + uvicorn.run( + "src.main:app", + host=os.getenv("APP_HOST", "0.0.0.0"), + port=int(os.getenv("APP_PORT", "8080")), + workers=1, + timeout_graceful_shutdown=5, + timeout_keep_alive=1, + access_log=False, + ) \ No newline at end of file diff --git a/src/sessions.py b/src/sessions.py new file mode 100644 index 00000000..82854049 --- /dev/null +++ b/src/sessions.py @@ -0,0 +1,33 @@ +import os +import secrets +import time +from datetime import datetime, timezone + +from redis import Redis +from redis.backoff import NoBackoff +from redis.retry import Retry + + +redis_client = Redis( + host=os.getenv("REDIS_HOST", "redis"), + port=int(os.getenv("REDIS_PORT", "6379")), + decode_responses=True, + socket_connect_timeout=2, + socket_timeout=2, + max_connections=10, + retry=Retry(NoBackoff(), 0), +) + +SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) +if SESSION_TTL_SECONDS <= 0: + raise RuntimeError("SESSION_TTL_SECONDS должен быть положительным") + + +def issue_session(user_id): + token = secrets.token_urlsafe(32) + expires_ms = int(time.time() * 1000) + SESSION_TTL_SECONDS * 1000 + redis_client.set("session:" + token, str(user_id), pxat=expires_ms) + expires_at = datetime.fromtimestamp( + expires_ms / 1000, timezone.utc + ).isoformat(timespec="milliseconds").replace("+00:00", "Z") + return token, expires_at