ЛР 3 — БВТ2302 — Рестеу — на 4 #76

Closed
Mandarin wants to merge 1 commits from Mandarin/mtusi2026lab3:main into main
28 changed files with 1049 additions and 37 deletions
+3 -12
View File
@@ -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
+28
View File
@@ -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"]
+4 -1
View File
@@ -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)
+94 -24
View File
@@ -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
+107
View File
@@ -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:
+9
View File
@@ -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`.
Не добавляю туда токены и пароли.
+30
View File
@@ -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);
+1
View File
@@ -0,0 +1 @@
CREATE INDEX chats_order_idx ON chats (created_at, id);
+11
View File
@@ -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);
+25
View File
@@ -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;
}
}
+7
View File
@@ -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;
}
+18
View File
@@ -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
+6
View File
@@ -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%
+5
View File
@@ -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
+6
View File
@@ -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%
+5
View File
@@ -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
+7
View File
@@ -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
+6
View File
@@ -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%
+8
View File
@@ -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"
+42
View File
@@ -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()
View File
+29
View File
@@ -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,
)
+14
View File
@@ -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", "Неверные данные авторизации")
+445
View File
@@ -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)
+36
View File
@@ -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()
+47
View File
@@ -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)
+23
View File
@@ -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,
)
+33
View File
@@ -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