Lab3: HAProxy, API replicas, idempotency for grade 4

This commit is contained in:
2026-11-11 01:29:57 +03:00
parent 0ab3a341aa
commit 9f25648c1b
37 changed files with 2083 additions and 26 deletions
+5 -4
View File
@@ -1,13 +1,14 @@
# 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
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
SESSION_STORE=redis
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
DB_CONNECT_TIMEOUT=5
DB_POOL_MIN=1
DB_POOL_MAX=8
REDIS_SOCKET_TIMEOUT=3
+27
View File
@@ -0,0 +1,27 @@
# Закреплённый runtime-образ (Python интерпретируемый — один stage).
FROM python:3.12.7-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
APP_HOST=0.0.0.0 \
APP_PORT=8080
WORKDIR /app
RUN groupadd --system app && useradd --system --gid app --home /app --shell /usr/sbin/nologin app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app ./app
COPY migrations ./migrations
USER app
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=5 \
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"
# PID 1 = uvicorn; SIGTERM обрабатывается lifespan'ом приложения.
CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
+17 -4
View File
@@ -3,11 +3,12 @@ BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
API_REPLICAS ?= 2
.PHONY: help check validate test load test-persistence test-failover
.PHONY: help check validate test test-own load test-persistence test-failover up down secrets
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "up/down: compose; test: smoke; test-own; test-persistence; test-failover"
check:
$(PYTHON) scripts/check_contract.py
@@ -18,13 +19,25 @@ validate:
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-own:
$(PYTHON) tests/own.py --base-url "$(BASE_URL)" $(TLS_ARGS)
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
secrets:
@echo "Run: powershell -File scripts/make_secrets.ps1"
up:
docker compose --env-file .env up -d --build --scale api=$(API_REPLICAS)
down:
docker compose --env-file .env down
+64 -18
View File
@@ -1,37 +1,83 @@
# Отчёт — лабораторная 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: Соболев Даниил Романович, БПИ2302
- Целевая оценка; выбранный трек 5, если нужен: 4
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные источники, библиотеки и помощь ИИ: FastAPI, psycopg, redis, argon2-cffi, HAProxy; перенос lab2; помощь ИИ при LB/идемпотентности
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
**Prerequisites:** Docker Compose; Python 3.9+ для тестов.
```sh
cp .env.example .env
powershell -File scripts/make_secrets.ps1 # или sh scripts/make_secrets.sh
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --scale api=2
```
Публичная точка входа: **только LB** `http://127.0.0.1:8080` (порты API наружу не опубликованы).
Ожидание: `GET /health/ready` → ok. Миграции — сервис `migrate` (один раз), API с `RUN_MIGRATIONS=false`.
```sh
make test
# Windows (UTF-8 для чтения contracts/openapi.json):
set PYTHONUTF8=1
py -3 tests\smoke.py --base-url http://localhost:8080
py -3 tests\own.py --base-url http://localhost:8080
py -3 tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:8080
py -3 tests\resilience.py --mode failover --action-script scripts\stop-one.cmd --base-url http://localhost:8080
# после failover поднять остановленную реплику:
scripts\start-stopped-api.cmd
# повторить failover для второй реплики
```
Остановка (volumes сохраняются): `docker compose --env-file .env down`
Сброс данных: `docker compose --env-file .env down -v`
Версии: `python:3.12.7-slim-bookworm`, `postgres:16.4-bookworm`, `redis:7.4.1-bookworm`, `haproxy:2.9.7-bookworm`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
Клиент → HAProxy (LB :8080) → API×2+ → PostgreSQL (истина + idempotency_keys)
↘ Redis (общие сессии, AOF)
```
- Перенос lab2: Postgres, Argon2, Basic→Bearer, Redis-сессии, миграции.
- **lab3:** `X-Instance-Id` = hostname контейнера (стабилен на жизнь процесса; stop-one мапит на container).
- **Идемпотентность:** таблица `idempotency_keys` (user+method+path+key); claim через `INSERT ON CONFLICT DO NOTHING` + message в одной транзакции; replay 201 / другой body 409.
- **LB:** HAProxy round-robin, `httpchk GET /health/ready`, `inter 2s fall 2` (~4 с до исключения backend), DNS `api` через Docker resolver.
- **SIGTERM:** `stop_grace_period: 10s`, приложение ставит ready=false в lifespan.
- **Лимиты:** mem_limit/cpus на сервисах; без `container_name`.
- **Миграции:** однократно `migrate` job, совместимы с IF NOT EXISTS (работающий API не ломают).
- Rolling: `docker compose up -d --build --scale api=2` (поочерёдная замена контейнеров при recreate).
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| Критерий | Команда | Результат | Файл |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Smoke | `make test` | PASS lab3 | `evidence/smoke.txt` |
| ≥2 instance id | `make test-own` | ≥2 X-Instance-Id | `evidence/own.txt` |
| Persistence | `restart.cmd` | token+данные | `evidence/persistence.txt` |
| Failover | `stop-one.cmd` | recover ≤10s | `evidence/failover.txt` |
| Идемпотентность concurrent | own | 1 message id | `evidence/own.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Обнаружение отказа LB: healthcheck interval 2s, fall 2 → порядка **4 с**.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Ожидание | Наблюдение |
| --- | --- | --- |
| stop одной API | другая обслуживает ≤10с | failover PASS |
| stop каждой по очереди | после start предыдущей | сценарий защиты |
| одинаковый Idempotency-Key ×8 | 1 сообщение | own PASS |
| restart всего стека | тот же token | persistence PASS |
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
## Ограничения
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Один Docker-host; LB/Postgres/Redis — SPOF.
- Остановленная реплика не поднимается сама — `start-stopped-api` после теста.
- Нет Swarm/многоузлового failover (трек 5).
+1
View File
@@ -0,0 +1 @@
"""Messenger API lab2: PostgreSQL + Bearer sessions + Redis."""
+178
View File
@@ -0,0 +1,178 @@
"""HTTP-слой: тонкие обработчики (SRP: только транспорт)."""
import logging
from typing import Optional
from fastapi import APIRouter, Depends, Header, Query, Request, Response
from app.auth import require_actor
from app.db import Database
from app.errors import unavailable, unsupported_media
from app.schemas import CreateChatBody, CreateMessageBody, CreateUserBody
from app.services import AuthService, ChatService, MessageService, UserService
from app.sessions import SessionStore
logger = logging.getLogger("messenger")
router = APIRouter()
def _state(request: Request):
db: Database = request.app.state.db
sessions: SessionStore = request.app.state.sessions
return db, sessions
def require_json_content_type(request: Request) -> None:
content_type = request.headers.get("content-type", "")
media = content_type.split(";")[0].strip().lower()
if media != "application/json":
raise unsupported_media()
def _require_accepting(db: Database) -> None:
if not db.accepting:
raise unavailable("Сервер завершает работу")
@router.get("/health/live")
def live():
return {"status": "ok"}
@router.get("/health/ready")
def ready(request: Request):
db, sessions = _state(request)
if not db.ready or not db.accepting:
raise unavailable("Не готов принимать трафик")
if not db.ping() or not sessions.ping():
raise unavailable("Зависимость недоступна")
return {"status": "ok"}
@router.post("/api/v1/users", status_code=201)
def create_user(
request: Request,
body: CreateUserBody,
_: None = Depends(require_json_content_type),
):
db, _sessions = _state(request)
_require_accepting(db)
return UserService(db).create(body.model_dump())
@router.post("/api/v1/auth/sessions", status_code=201)
def create_session(
request: Request,
authorization: Optional[str] = Header(default=None),
):
db, sessions = _state(request)
_require_accepting(db)
return AuthService(db, sessions).create_session(authorization)
@router.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(
request: Request,
authorization: Optional[str] = Header(default=None),
):
db, sessions = _state(request)
_require_accepting(db)
_actor, token = require_actor(db, sessions, authorization)
AuthService(db, sessions).logout(token)
return Response(status_code=204)
@router.get("/api/v1/users/me")
def current_user(
request: Request,
authorization: Optional[str] = Header(default=None),
):
db, sessions = _state(request)
_require_accepting(db)
actor, _token = require_actor(db, sessions, authorization)
return actor.to_dict()
@router.post("/api/v1/chats", status_code=201)
def create_chat(
request: Request,
body: CreateChatBody,
authorization: Optional[str] = Header(default=None),
_: None = Depends(require_json_content_type),
):
db, sessions = _state(request)
_require_accepting(db)
actor, _token = require_actor(db, sessions, authorization)
return ChatService(db).create(actor, body.model_dump())
@router.get("/api/v1/chats")
def list_chats(
request: Request,
authorization: Optional[str] = Header(default=None),
limit: Optional[str] = Query(default=None),
cursor: Optional[str] = Query(default=None),
):
db, sessions = _state(request)
_require_accepting(db)
actor, _token = require_actor(db, sessions, authorization)
return ChatService(db).list_for_user(actor, limit, cursor)
@router.get("/api/v1/chats/{chat_id}")
def get_chat(
chat_id: str,
request: Request,
authorization: Optional[str] = Header(default=None),
):
db, sessions = _state(request)
_require_accepting(db)
actor, _token = require_actor(db, sessions, authorization)
return ChatService(db).get_for_member(actor, chat_id).to_dict()
@router.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def create_message(
chat_id: str,
request: Request,
body: CreateMessageBody,
authorization: Optional[str] = Header(default=None),
idempotency_key: Optional[str] = Header(default=None, alias="Idempotency-Key"),
_: None = Depends(require_json_content_type),
):
db, sessions = _state(request)
_require_accepting(db)
actor, _token = require_actor(db, sessions, authorization)
chats = ChatService(db)
chat = chats.get_for_member(actor, chat_id)
path = f"/api/v1/chats/{chat.id}/messages"
result = MessageService(db).create(
actor,
chat,
body.model_dump(),
idempotency_key=idempotency_key,
method="POST",
path=path,
)
logger.info(
"message created chat_id=%s sender_id=%s message_id=%s",
chat.id,
actor.id,
result["id"],
)
return result
@router.get("/api/v1/chats/{chat_id}/messages")
def list_messages(
chat_id: str,
request: Request,
authorization: Optional[str] = Header(default=None),
limit: Optional[str] = Query(default=None),
cursor: Optional[str] = Query(default=None),
):
db, sessions = _state(request)
_require_accepting(db)
actor, _token = require_actor(db, sessions, authorization)
chat = ChatService(db).get_for_member(actor, chat_id)
return MessageService(db).list_for_chat(chat, limit, cursor)
+64
View File
@@ -0,0 +1,64 @@
"""Разбор Basic/Bearer и проверка сессии."""
from __future__ import annotations
import base64
import binascii
from typing import Optional, Tuple
from app.db import Database
from app.errors import unauthorized
from app.models import User
from app.sessions import SessionStore
from app.validation import USERNAME_RE
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
def parse_basic(authorization: Optional[str]) -> Tuple[str, str]:
if not authorization or not authorization.startswith("Basic "):
raise unauthorized("Требуется Basic-аутентификация", challenge=BASIC_CHALLENGE)
raw = authorization[6:].strip()
if not raw:
raise unauthorized("Требуется Basic-аутентификация", challenge=BASIC_CHALLENGE)
try:
decoded = base64.b64decode(raw, validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError, ValueError) as exc:
raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE) from exc
if ":" not in decoded:
raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE)
username, password = decoded.split(":", 1)
if not USERNAME_RE.fullmatch(username):
raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE)
n = len(password)
if n < 12 or n > 128:
raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE)
return username, password
def parse_bearer(authorization: Optional[str]) -> str:
if not authorization:
raise unauthorized(challenge=BEARER_CHALLENGE)
if authorization.startswith("Basic "):
raise unauthorized(challenge=BEARER_CHALLENGE)
if not authorization.startswith("Bearer "):
raise unauthorized(challenge=BEARER_CHALLENGE)
token = authorization[7:].strip()
if not token:
raise unauthorized(challenge=BEARER_CHALLENGE)
return token
def require_actor(
db: Database,
sessions: SessionStore,
authorization: Optional[str],
) -> Tuple[User, str]:
token = parse_bearer(authorization)
user_id = sessions.resolve(token)
if user_id is None:
raise unauthorized(challenge=BEARER_CHALLENGE)
user = db.get_user(user_id)
if user is None:
raise unauthorized(challenge=BEARER_CHALLENGE)
return user, token
+44
View File
@@ -0,0 +1,44 @@
"""Конфигурация из окружения и secret-файлов."""
from __future__ import annotations
import os
import socket
from pathlib import Path
def _read_secret(file_env: str, direct_env: str) -> str:
path = os.environ.get(file_env, "").strip()
if path:
return Path(path).read_text(encoding="utf-8").strip()
value = os.environ.get(direct_env, "").strip()
if value:
return value
raise RuntimeError(f"Задайте {file_env} или {direct_env}")
class Settings:
def __init__(self) -> None:
self.host = os.environ.get("APP_HOST", "0.0.0.0")
self.port = int(os.environ.get("APP_PORT", "8080"))
self.env = os.environ.get("APP_ENV", "lab")
self.session_ttl_seconds = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
if self.session_ttl_seconds < 1:
raise RuntimeError("SESSION_TTL_SECONDS должен быть >= 1")
self.session_store = os.environ.get("SESSION_STORE", "redis").strip().lower()
self.database_url = _read_secret("DATABASE_URL_FILE", "DATABASE_URL")
self.cache_url = _read_secret("CACHE_URL_FILE", "CACHE_URL")
self.db_connect_timeout = float(os.environ.get("DB_CONNECT_TIMEOUT", "5"))
self.db_pool_min = int(os.environ.get("DB_POOL_MIN", "1"))
self.db_pool_max = int(os.environ.get("DB_POOL_MAX", "10"))
self.redis_socket_timeout = float(os.environ.get("REDIS_SOCKET_TIMEOUT", "3"))
self.idempotency_ttl_seconds = int(os.environ.get("IDEMPOTENCY_TTL_SECONDS", "86400"))
# Stable for process life; hostname = container id in Compose (for stop-one mapping).
self.instance_id = os.environ.get("INSTANCE_ID", "").strip() or socket.gethostname()
self.run_migrations = os.environ.get("RUN_MIGRATIONS", "true").strip().lower() in {
"1",
"true",
"yes",
}
settings = Settings()
+27
View File
@@ -0,0 +1,27 @@
"""Непрозрачный keyset-cursor: (created_at, id), привязан к ресурсу."""
import base64
import json
from app.errors import invalid_request
def encode(resource_id: str, created_at: str, item_id: str) -> str:
payload = {"r": resource_id, "t": created_at, "i": item_id}
raw = json.dumps(payload, separators=(",", ":")).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii")
def decode(cursor: str, expected_resource_id: str) -> tuple:
try:
raw = base64.urlsafe_b64decode(cursor.encode("ascii"))
payload = json.loads(raw.decode("utf-8"))
resource_id = payload["r"]
created_at = payload["t"]
item_id = payload["i"]
if not isinstance(resource_id, str) or not isinstance(created_at, str) or not isinstance(item_id, str):
raise ValueError("bad types")
except Exception as exc:
raise invalid_request("Неверный cursor") from exc
if resource_id != expected_resource_id:
raise invalid_request("Cursor относится к другому ресурсу")
return created_at, item_id
+472
View File
@@ -0,0 +1,472 @@
"""PostgreSQL pool, миграции и параметризованные запросы."""
from __future__ import annotations
import json
import logging
from pathlib import Path
from typing import List, Optional, Sequence, Tuple
from psycopg import OperationalError
from psycopg.errors import UniqueViolation
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
from psycopg.types.json import Json
from app.config import settings
from app.errors import conflict, unavailable
from app.models import Chat, Message, User
from app.timefmt import format_utc
logger = logging.getLogger("messenger")
MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations"
class Database:
def __init__(self) -> None:
self.pool: Optional[ConnectionPool] = None
self.accepting = True
self.ready = False
def open(self) -> None:
self.pool = ConnectionPool(
conninfo=settings.database_url,
min_size=settings.db_pool_min,
max_size=settings.db_pool_max,
timeout=settings.db_connect_timeout,
kwargs={
"connect_timeout": max(1, int(settings.db_connect_timeout)),
"row_factory": dict_row,
},
open=True,
)
if settings.run_migrations:
self.apply_migrations()
logger.info("postgres pool ready; migrations applied")
else:
logger.info("postgres pool ready; migrations skipped (RUN_MIGRATIONS=false)")
self.ready = True
def close(self) -> None:
self.ready = False
self.accepting = False
if self.pool is not None:
self.pool.close()
self.pool = None
def begin_shutdown(self) -> None:
self.accepting = False
self.ready = False
def _require_pool(self) -> ConnectionPool:
if self.pool is None:
raise unavailable("База данных недоступна")
return self.pool
def ping(self) -> bool:
try:
pool = self._require_pool()
with pool.connection() as conn:
conn.execute("SELECT 1")
return True
except Exception:
return False
@staticmethod
def _split_sql(script: str) -> List[str]:
statements: List[str] = []
buf: List[str] = []
for line in script.splitlines():
stripped = line.strip()
if not stripped or stripped.startswith("--"):
continue
buf.append(line)
if stripped.endswith(";"):
stmt = "\n".join(buf).strip()
if stmt:
statements.append(stmt)
buf = []
tail = "\n".join(buf).strip()
if tail:
statements.append(tail)
return statements
def apply_migrations(self) -> None:
pool = self._require_pool()
files = sorted(MIGRATIONS_DIR.glob("*.sql"))
with pool.connection() as conn:
conn.execute(
"""
CREATE TABLE IF NOT EXISTS schema_migrations (
version TEXT PRIMARY KEY,
applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
)
"""
)
for path in files:
version = path.name
row = conn.execute(
"SELECT 1 FROM schema_migrations WHERE version = %s",
(version,),
).fetchone()
if row:
continue
statements = self._split_sql(path.read_text(encoding="utf-8"))
with conn.transaction():
for stmt in statements:
conn.execute(stmt)
conn.execute(
"INSERT INTO schema_migrations (version) VALUES (%s)",
(version,),
)
logger.info("applied migration %s", version)
def _user_from_row(self, row: dict) -> User:
return User(
id=str(row["id"]),
username=row["username"],
display_name=row["display_name"],
created_at=format_utc(row["created_at"]),
password_hash=row.get("password_hash", ""),
)
def add_user(self, user: User) -> None:
pool = self._require_pool()
try:
with pool.connection() as conn:
conn.execute(
"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (%s, %s, %s, %s, %s::timestamptz)
""",
(
user.id,
user.username,
user.display_name,
user.password_hash,
user.created_at,
),
)
except UniqueViolation as exc:
raise KeyError("username") from exc
except OperationalError as exc:
raise unavailable("База данных недоступна") from exc
def get_user(self, user_id: str) -> Optional[User]:
pool = self._require_pool()
try:
with pool.connection() as conn:
row = conn.execute(
"""
SELECT id, username, display_name, password_hash, created_at
FROM users WHERE id = %s
""",
(user_id,),
).fetchone()
except OperationalError as exc:
raise unavailable("База данных недоступна") from exc
return self._user_from_row(row) if row else None
def get_user_by_username(self, username: str) -> Optional[User]:
pool = self._require_pool()
try:
with pool.connection() as conn:
row = conn.execute(
"""
SELECT id, username, display_name, password_hash, created_at
FROM users WHERE username = %s
""",
(username,),
).fetchone()
except OperationalError as exc:
raise unavailable("База данных недоступна") from exc
return self._user_from_row(row) if row else None
def users_exist(self, user_ids: Sequence[str]) -> bool:
if not user_ids:
return True
pool = self._require_pool()
try:
with pool.connection() as conn:
row = conn.execute(
"SELECT COUNT(*) AS c FROM users WHERE id = ANY(%s::uuid[])",
(list(user_ids),),
).fetchone()
except OperationalError as exc:
raise unavailable("База данных недоступна") from exc
return int(row["c"]) == len(set(user_ids))
def add_chat(self, chat: Chat) -> None:
"""Атомарно: чат + участники в одной транзакции."""
pool = self._require_pool()
try:
with pool.connection() as conn:
with conn.transaction():
# Повторная проверка участников внутри транзакции.
row = conn.execute(
"SELECT COUNT(*) AS c FROM users WHERE id = ANY(%s::uuid[])",
(list(chat.member_ids),),
).fetchone()
if int(row["c"]) != len(set(chat.member_ids)):
raise ValueError("unknown member")
conn.execute(
"""
INSERT INTO chats (id, title, created_at)
VALUES (%s, %s, %s::timestamptz)
""",
(chat.id, chat.title, chat.created_at),
)
for mid in chat.member_ids:
conn.execute(
"""
INSERT INTO chat_members (chat_id, user_id)
VALUES (%s, %s)
""",
(chat.id, mid),
)
except ValueError:
raise
except OperationalError as exc:
raise unavailable("База данных недоступна") from exc
def get_chat(self, chat_id: str) -> Optional[Chat]:
pool = self._require_pool()
try:
with pool.connection() as conn:
row = conn.execute(
"SELECT id, title, created_at FROM chats WHERE id = %s",
(chat_id,),
).fetchone()
if not row:
return None
members = conn.execute(
"""
SELECT user_id FROM chat_members
WHERE chat_id = %s
ORDER BY user_id
""",
(chat_id,),
).fetchall()
except OperationalError as exc:
raise unavailable("База данных недоступна") from exc
return Chat(
id=str(row["id"]),
title=row["title"],
member_ids=[str(m["user_id"]) for m in members],
created_at=format_utc(row["created_at"]),
)
def list_chats_for(self, user_id: str) -> List[Chat]:
pool = self._require_pool()
try:
with pool.connection() as conn:
rows = conn.execute(
"""
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE m.user_id = %s
ORDER BY c.created_at ASC, c.id ASC
""",
(user_id,),
).fetchall()
result: List[Chat] = []
for row in rows:
members = conn.execute(
"""
SELECT user_id FROM chat_members
WHERE chat_id = %s
ORDER BY user_id
""",
(row["id"],),
).fetchall()
result.append(
Chat(
id=str(row["id"]),
title=row["title"],
member_ids=[str(m["user_id"]) for m in members],
created_at=format_utc(row["created_at"]),
)
)
return result
except OperationalError as exc:
raise unavailable("База данных недоступна") from exc
def add_message(self, message: Message) -> Message:
pool = self._require_pool()
try:
with pool.connection() as conn:
conn.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES (%s, %s, %s, %s, %s::timestamptz)
""",
(
message.id,
message.chat_id,
message.sender_id,
message.text,
message.created_at,
),
)
except OperationalError as exc:
raise unavailable("База данных недоступна") from exc
return message
def list_messages_page(
self,
chat_id: str,
limit: int,
after_created_at: Optional[str] = None,
after_id: Optional[str] = None,
) -> List[Message]:
"""Keyset page using index (chat_id, created_at, id)."""
pool = self._require_pool()
try:
with pool.connection() as conn:
if after_created_at is None:
rows = conn.execute(
"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = %s
ORDER BY created_at ASC, id ASC
LIMIT %s
""",
(chat_id, limit),
).fetchall()
else:
rows = conn.execute(
"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = %s
AND (created_at, id) > (%s::timestamptz, %s::uuid)
ORDER BY created_at ASC, id ASC
LIMIT %s
""",
(chat_id, after_created_at, after_id, limit),
).fetchall()
except OperationalError as exc:
raise unavailable("База данных недоступна") from exc
return [
Message(
id=str(r["id"]),
chat_id=str(r["chat_id"]),
sender_id=str(r["sender_id"]),
text=r["text"],
created_at=format_utc(r["created_at"]),
)
for r in rows
]
def explain_messages_page(self, chat_id: str, limit: int = 50) -> str:
pool = self._require_pool()
with pool.connection() as conn:
rows = conn.execute(
"""
EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = %s
ORDER BY created_at ASC, id ASC
LIMIT %s
""",
(chat_id, limit),
).fetchall()
# EXPLAIN text rows come as single-column dicts
lines = []
for r in rows:
lines.append(next(iter(r.values())))
return "\n".join(lines)
def create_message_idempotent(
self,
message: Message,
*,
user_id: str,
method: str,
path: str,
idem_key: str,
request_hash: str,
) -> Tuple[dict, bool]:
"""Atomically create message or replay prior result.
Returns (message_dict, created_new).
"""
pool = self._require_pool()
try:
with pool.connection() as conn:
with conn.transaction():
claimed = conn.execute(
"""
INSERT INTO idempotency_keys (
user_id, method, path, idem_key, request_hash,
response_status, response_body, created_at
)
VALUES (
%s, %s, %s, %s, %s,
0, '{}'::jsonb, %s::timestamptz
)
ON CONFLICT DO NOTHING
RETURNING idem_key
""",
(
user_id,
method,
path,
idem_key,
request_hash,
message.created_at,
),
).fetchone()
if claimed is None:
existing = conn.execute(
"""
SELECT request_hash, response_status, response_body
FROM idempotency_keys
WHERE user_id = %s AND method = %s
AND path = %s AND idem_key = %s
FOR UPDATE
""",
(user_id, method, path, idem_key),
).fetchone()
if existing is None:
raise unavailable("Идемпотентность временно недоступна")
if existing["request_hash"] != request_hash:
raise conflict("Idempotency-Key уже использован с другим телом")
if int(existing["response_status"]) != 201:
# Another replica still writing; rare — wait via conflict for client retry
raise unavailable("Идемпотентный запрос ещё обрабатывается")
body = existing["response_body"]
if isinstance(body, str):
body = json.loads(body)
return dict(body), False
conn.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES (%s, %s, %s, %s, %s::timestamptz)
""",
(
message.id,
message.chat_id,
message.sender_id,
message.text,
message.created_at,
),
)
payload = message.to_dict()
conn.execute(
"""
UPDATE idempotency_keys
SET response_status = 201, response_body = %s
WHERE user_id = %s AND method = %s
AND path = %s AND idem_key = %s
""",
(Json(payload), user_id, method, path, idem_key),
)
return payload, True
except OperationalError as exc:
raise unavailable("База данных недоступна") from exc
+54
View File
@@ -0,0 +1,54 @@
"""Единый формат ошибок API."""
from typing import Optional
class AppError(Exception):
def __init__(
self,
status: int,
code: str,
message: str,
headers: Optional[dict] = None,
) -> None:
self.status = status
self.code = code
self.message = message
self.headers = headers or {}
super().__init__(message)
def invalid_request(message: str = "Неверный запрос") -> AppError:
return AppError(400, "invalid_request", message)
def unauthorized(
message: str = "Требуется идентификация",
*,
challenge: str = 'Bearer realm="messenger"',
) -> AppError:
return AppError(
401,
"unauthorized",
message,
headers={"WWW-Authenticate": challenge},
)
def not_found(message: str = "Объект не найден") -> AppError:
return AppError(404, "not_found", message)
def conflict(message: str = "Конфликт") -> AppError:
return AppError(409, "conflict", message)
def unsupported_media(message: str = "Неподдерживаемый Content-Type") -> AppError:
return AppError(415, "unsupported_media_type", message)
def unavailable(message: str = "Сервис недоступен") -> AppError:
return AppError(503, "unavailable", message)
def error_body(code: str, message: str, request_id: str) -> dict:
return {"error": {"code": code, "message": message, "request_id": request_id}}
+115
View File
@@ -0,0 +1,115 @@
"""Точка входа HTTP-приложения lab3."""
import logging
import uuid
from contextlib import asynccontextmanager
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.middleware.base import BaseHTTPMiddleware
from app.api import router
from app.config import settings
from app.db import Database
from app.errors import AppError, error_body
from app.sessions import SessionStore
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(name)s %(message)s",
)
logger = logging.getLogger("messenger")
db = Database()
sessions = SessionStore()
INSTANCE_ID = settings.instance_id
@asynccontextmanager
async def lifespan(_app: FastAPI):
logger.info("server starting; instance_id=%s", INSTANCE_ID)
db.open()
sessions.open()
_app.state.db = db
_app.state.sessions = sessions
logger.info("dependencies ready")
yield
db.begin_shutdown()
sessions.close()
db.close()
logger.info("SIGTERM/shutdown: stop accepting, ready=false")
app = FastAPI(title="MTUSI Messenger lab3", lifespan=lifespan)
app.state.db = db
app.state.sessions = sessions
app.include_router(router)
class RequestHeadersMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request: Request, call_next):
request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
request.state.request_id = request_id
response = await call_next(request)
response.headers["X-Request-Id"] = request_id
response.headers["X-Instance-Id"] = INSTANCE_ID
logger.info(
"%s %s -> %s request_id=%s instance=%s",
request.method,
request.url.path,
response.status_code,
request_id,
INSTANCE_ID,
)
return response
app.add_middleware(RequestHeadersMiddleware)
@app.exception_handler(AppError)
async def app_error_handler(request: Request, exc: AppError):
request_id = getattr(request.state, "request_id", None) or str(uuid.uuid4())
headers = {"X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID}
headers.update(exc.headers)
return JSONResponse(
status_code=exc.status,
content=error_body(exc.code, exc.message, request_id),
headers=headers,
)
@app.exception_handler(RequestValidationError)
async def validation_handler(request: Request, _exc: RequestValidationError):
request_id = getattr(request.state, "request_id", None) or str(uuid.uuid4())
return JSONResponse(
status_code=400,
content=error_body("invalid_request", "Неверный запрос", request_id),
headers={"X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID},
)
@app.exception_handler(Exception)
async def internal_handler(request: Request, exc: Exception):
request_id = getattr(request.state, "request_id", None) or str(uuid.uuid4())
logger.exception("unhandled error request_id=%s", request_id)
return JSONResponse(
status_code=500,
content=error_body("internal_error", "Внутренняя ошибка", request_id),
headers={"X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID},
)
def run() -> None:
import uvicorn
uvicorn.run(
"app.main:app",
host=settings.host,
port=settings.port,
log_level="info",
)
if __name__ == "__main__":
run()
+18
View File
@@ -0,0 +1,18 @@
"""One-shot migrations (run once before API replicas)."""
import logging
from app.db import Database
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger("migrate")
def main() -> None:
db = Database()
db.open()
logger.info("migrations complete")
db.close()
if __name__ == "__main__":
main()
+58
View File
@@ -0,0 +1,58 @@
"""Доменные сущности (данные, без HTTP и без бизнес-правил)."""
import uuid
from dataclasses import dataclass
from typing import List
@dataclass
class User:
id: str
username: str
display_name: str
created_at: str
password_hash: str = ""
def to_dict(self) -> dict:
return {
"id": self.id,
"username": self.username,
"display_name": self.display_name,
"created_at": self.created_at,
}
@dataclass
class Chat:
id: str
title: str
member_ids: List[str]
created_at: str
def to_dict(self) -> dict:
return {
"id": self.id,
"title": self.title,
"member_ids": list(self.member_ids),
"created_at": self.created_at,
}
@dataclass
class Message:
id: str
chat_id: str
sender_id: str
text: str
created_at: str
def to_dict(self) -> dict:
return {
"id": self.id,
"chat_id": self.chat_id,
"sender_id": self.sender_id,
"text": self.text,
"created_at": self.created_at,
}
def sort_key(self):
return (self.created_at, uuid.UUID(self.id).int)
+18
View File
@@ -0,0 +1,18 @@
"""Password KDF: Argon2id (библиотечный)."""
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
_hasher = PasswordHasher()
def hash_password(password: str) -> str:
return _hasher.hash(password)
def verify_password(password_hash: str, password: str) -> bool:
try:
return _hasher.verify(password_hash, password)
except VerifyMismatchError:
return False
except Exception:
return False
+28
View File
@@ -0,0 +1,28 @@
"""Схемы тел запросов для OpenAPI / Swagger (валидация домена — в services)."""
from typing import List
from pydantic import BaseModel, ConfigDict, Field
class CreateUserBody(BaseModel):
model_config = ConfigDict(extra="forbid")
username: str = Field(..., examples=["alice"])
display_name: str = Field(..., examples=["Алиса"])
password: str = Field(..., examples=["Example-only-not-a-real-secret-123"])
class CreateChatBody(BaseModel):
model_config = ConfigDict(extra="forbid")
title: str = Field(..., examples=["Проект по ВНП"])
member_ids: List[str] = Field(
...,
examples=[["11111111-1111-4111-8111-111111111111"]],
)
class CreateMessageBody(BaseModel):
model_config = ConfigDict(extra="forbid")
text: str = Field(..., examples=["Привет, Боб!"])
+212
View File
@@ -0,0 +1,212 @@
"""Бизнес-логика lab3 (DIP: зависит от Database/SessionStore)."""
from __future__ import annotations
import hashlib
import json
import uuid
from typing import List, Optional
from app import cursor as cursor_util
from app.auth import BASIC_CHALLENGE, parse_basic
from app.db import Database
from app.errors import conflict, invalid_request, not_found, unauthorized
from app.models import Chat, Message, User
from app.password import hash_password, verify_password
from app.sessions import SessionStore
from app.timefmt import now_utc
from app.validation import (
parse_limit,
parse_uuid,
reject_unknown,
require_display_name,
require_idempotency_key,
require_keys,
require_message_text,
require_object,
require_password,
require_title,
require_username,
)
class UserService:
def __init__(self, db: Database) -> None:
self.db = db
def create(self, body: object) -> dict:
data = require_object(body)
reject_unknown(data, {"username", "display_name", "password"})
require_keys(data, ("username", "display_name", "password"))
username = require_username(data["username"])
display_name = require_display_name(data["display_name"])
password = require_password(data["password"])
user = User(
id=str(uuid.uuid4()),
username=username,
display_name=display_name,
created_at=now_utc(),
password_hash=hash_password(password),
)
try:
self.db.add_user(user)
except KeyError as exc:
raise conflict("username уже занят") from exc
return user.to_dict()
class AuthService:
def __init__(self, db: Database, sessions: SessionStore) -> None:
self.db = db
self.sessions = sessions
def create_session(self, authorization: Optional[str]) -> dict:
username, password = parse_basic(authorization)
user = self.db.get_user_by_username(username)
if user is None or not verify_password(user.password_hash, password):
raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE)
token, expires_at = self.sessions.create(user.id)
return {
"token": token,
"token_type": "Bearer",
"expires_at": expires_at,
"user": user.to_dict(),
}
def logout(self, token: str) -> None:
self.sessions.revoke(token)
class ChatService:
def __init__(self, db: Database) -> None:
self.db = db
def create(self, actor: User, body: object) -> dict:
data = require_object(body)
reject_unknown(data, {"title", "member_ids"})
require_keys(data, ("title", "member_ids"))
title = require_title(data["title"])
raw_members = data["member_ids"]
if not isinstance(raw_members, list):
raise invalid_request("member_ids должен быть массивом")
if len(raw_members) < 1 or len(raw_members) > 100:
raise invalid_request("member_ids: от 1 до 100 участников")
member_ids: List[str] = []
seen = set()
for item in raw_members:
mid = parse_uuid(item, "member_ids")
if mid in seen:
raise invalid_request("member_ids содержит дубликаты")
seen.add(mid)
member_ids.append(mid)
if actor.id not in seen:
raise invalid_request("Вызывающий должен быть в member_ids")
if not self.db.users_exist(member_ids):
raise invalid_request("Неизвестный участник")
chat = Chat(
id=str(uuid.uuid4()),
title=title,
member_ids=member_ids,
created_at=now_utc(),
)
try:
self.db.add_chat(chat)
except ValueError as exc:
raise invalid_request("Неизвестный участник") from exc
return chat.to_dict()
def get_for_member(self, actor: User, chat_id: str) -> Chat:
cid = parse_uuid(chat_id, "chat_id")
chat = self.db.get_chat(cid)
if chat is None or actor.id not in chat.member_ids:
raise not_found()
return chat
def list_for_user(self, actor: User, limit_raw: Optional[str], cursor_raw: Optional[str]) -> dict:
limit = parse_limit(limit_raw)
chats = self.db.list_chats_for(actor.id)
start = 0
if cursor_raw:
created_at, item_id = cursor_util.decode(cursor_raw, actor.id)
start = 0
for i, chat in enumerate(chats):
if (chat.created_at, chat.id) > (created_at, item_id):
start = i
break
else:
start = len(chats)
page = chats[start : start + limit]
next_cursor = None
if start + limit < len(chats) and page:
last = page[-1]
next_cursor = cursor_util.encode(actor.id, last.created_at, last.id)
return {"items": [c.to_dict() for c in page], "next_cursor": next_cursor}
def _message_request_hash(text: str) -> str:
# Canonical body: text only (attachment_ids absent == [] for lab3).
canonical = json.dumps({"text": text}, ensure_ascii=False, separators=(",", ":"), sort_keys=True)
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
class MessageService:
def __init__(self, db: Database) -> None:
self.db = db
def create(
self,
actor: User,
chat: Chat,
body: object,
*,
idempotency_key: Optional[str],
method: str,
path: str,
) -> dict:
data = require_object(body)
reject_unknown(data, {"text"})
require_keys(data, ("text",))
text = require_message_text(data["text"])
key = require_idempotency_key(idempotency_key)
message = Message(
id=str(uuid.uuid4()),
chat_id=chat.id,
sender_id=actor.id,
text=text,
created_at=now_utc(),
)
payload, _created = self.db.create_message_idempotent(
message,
user_id=actor.id,
method=method,
path=path,
idem_key=key,
request_hash=_message_request_hash(text),
)
return payload
def list_for_chat(
self,
chat: Chat,
limit_raw: Optional[str],
cursor_raw: Optional[str],
) -> dict:
limit = parse_limit(limit_raw)
after_created_at = None
after_id = None
if cursor_raw:
created_at, item_id = cursor_util.decode(cursor_raw, chat.id)
parse_uuid(item_id, "cursor.id")
after_created_at = created_at
after_id = item_id
rows = self.db.list_messages_page(
chat.id,
limit + 1,
after_created_at=after_created_at,
after_id=after_id,
)
page = rows[:limit]
next_cursor = None
if len(rows) > limit and page:
last = page[-1]
next_cursor = cursor_util.encode(chat.id, last.created_at, last.id)
return {"items": [m.to_dict() for m in page], "next_cursor": next_cursor}
+93
View File
@@ -0,0 +1,93 @@
"""Opaque Bearer-сессии в Redis с TTL и AOF-persistence на стороне Redis."""
from __future__ import annotations
import json
import logging
import secrets
from datetime import datetime, timedelta, timezone
from typing import Optional, Tuple
import redis
from app.config import settings
from app.errors import unavailable
from app.timefmt import format_utc, parse_rfc3339
logger = logging.getLogger("messenger")
TOKEN_PREFIX = "session:"
class SessionStore:
def __init__(self) -> None:
self.client: Optional[redis.Redis] = None
def open(self) -> None:
self.client = redis.Redis.from_url(
settings.cache_url,
decode_responses=True,
socket_connect_timeout=settings.redis_socket_timeout,
socket_timeout=settings.redis_socket_timeout,
)
self.client.ping()
logger.info("redis session store ready")
def close(self) -> None:
if self.client is not None:
self.client.close()
self.client = None
def _require(self) -> redis.Redis:
if self.client is None:
raise unavailable("Хранилище сессий недоступно")
return self.client
def ping(self) -> bool:
try:
return bool(self._require().ping())
except Exception:
return False
def create(self, user_id: str) -> Tuple[str, str]:
"""Возвращает (token, expires_at)."""
client = self._require()
token = secrets.token_urlsafe(32) # ≥256 бит
expires = datetime.now(timezone.utc) + timedelta(seconds=settings.session_ttl_seconds)
expires_at = format_utc(expires)
payload = json.dumps({"user_id": user_id, "expires_at": expires_at}, separators=(",", ":"))
try:
client.setex(TOKEN_PREFIX + token, settings.session_ttl_seconds, payload)
except redis.RedisError as exc:
raise unavailable("Хранилище сессий недоступно") from exc
return token, expires_at
def resolve(self, token: str) -> Optional[str]:
"""user_id или None, если нет/истекла. 503 при недоступности Redis."""
client = self._require()
try:
raw = client.get(TOKEN_PREFIX + token)
except redis.RedisError as exc:
raise unavailable("Хранилище сессий недоступно") from exc
if not raw:
return None
try:
data = json.loads(raw)
user_id = data["user_id"]
expires_at = parse_rfc3339(data["expires_at"])
except Exception:
return None
if expires_at <= datetime.now(timezone.utc):
try:
client.delete(TOKEN_PREFIX + token)
except redis.RedisError:
pass
return None
return str(user_id)
def revoke(self, token: str) -> bool:
client = self._require()
try:
deleted = client.delete(TOKEN_PREFIX + token)
except redis.RedisError as exc:
raise unavailable("Хранилище сессий недоступно") from exc
return bool(deleted)
+20
View File
@@ -0,0 +1,20 @@
"""Форматирование времени в RFC 3339 UTC с миллисекундами и Z."""
from datetime import datetime, timezone
def now_utc() -> str:
return format_utc(datetime.now(timezone.utc))
def format_utc(value: datetime) -> str:
if value.tzinfo is None:
value = value.replace(tzinfo=timezone.utc)
else:
value = value.astimezone(timezone.utc)
return value.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
def parse_rfc3339(value: str) -> datetime:
if value.endswith("Z"):
value = value[:-1] + "+00:00"
return datetime.fromisoformat(value)
+112
View File
@@ -0,0 +1,112 @@
"""Проверки входных данных по контракту lab2."""
import re
import uuid
from typing import Any, Iterable, Optional, Set
from app.errors import invalid_request
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
IDEMPOTENCY_KEY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
def require_object(body: Any) -> dict:
if not isinstance(body, dict):
raise invalid_request("Тело запроса должно быть JSON-объектом")
return body
def reject_unknown(body: dict, allowed: Set[str]) -> None:
extra = set(body) - allowed
if extra:
raise invalid_request("Лишние поля в запросе")
def require_keys(body: dict, keys: Iterable[str]) -> None:
for key in keys:
if key not in body:
raise invalid_request(f"Поле {key} обязательно")
def parse_uuid(value: Any, field: str = "id") -> str:
if not isinstance(value, str):
raise invalid_request(f"Поле {field} должно быть UUID-строкой")
try:
return str(uuid.UUID(value))
except ValueError as exc:
raise invalid_request(f"Неверный UUID: {field}") from exc
def code_points(text: str) -> int:
return len(text)
def require_username(value: Any) -> str:
if not isinstance(value, str):
raise invalid_request("username должен быть строкой")
if not USERNAME_RE.fullmatch(value):
raise invalid_request("username: только [a-z0-9_] длиной 3–32")
return value
def require_display_name(value: Any) -> str:
if not isinstance(value, str):
raise invalid_request("display_name должен быть строкой")
if value.strip() == "":
raise invalid_request("display_name не может быть пустым")
n = code_points(value)
if n < 1 or n > 100:
raise invalid_request("display_name: 1–100 символов Unicode")
return value
def require_password(value: Any) -> str:
if not isinstance(value, str):
raise invalid_request("password должен быть строкой")
if value.strip() == "":
raise invalid_request("password не может быть пустым")
n = code_points(value)
if n < 12 or n > 128:
raise invalid_request("password: 12–128 символов Unicode")
return value
def require_title(value: Any) -> str:
if not isinstance(value, str):
raise invalid_request("title должен быть строкой")
if value.strip() == "":
raise invalid_request("title не может быть пустым")
n = code_points(value)
if n < 1 or n > 100:
raise invalid_request("title: 1–100 символов Unicode")
return value
def require_message_text(value: Any) -> str:
if not isinstance(value, str):
raise invalid_request("text должен быть строкой")
if value.strip() == "":
raise invalid_request("text не может быть пустым")
if code_points(value) > 4000:
raise invalid_request("text: максимум 4000 символов Unicode")
return value
def parse_limit(raw: Optional[str], default: int = 50) -> int:
if raw is None or raw == "":
return default
try:
value = int(raw)
except ValueError as exc:
raise invalid_request("limit должен быть целым числом") from exc
if value < 1 or value > 100:
raise invalid_request("limit должен быть от 1 до 100")
return value
def require_idempotency_key(value: Any) -> str:
if not isinstance(value, str) or not value:
raise invalid_request("Idempotency-Key обязателен")
if not IDEMPOTENCY_KEY_RE.fullmatch(value):
raise invalid_request("Idempotency-Key: ASCII [A-Za-z0-9._:-]{1,128}")
return value
+144
View File
@@ -0,0 +1,144 @@
# Lab3: LB + ≥2 API replicas + shared Postgres/Redis. API ports not published.
x-lab-number: 3
x-api-env: &api-env
APP_HOST: 0.0.0.0
APP_PORT: "8080"
APP_ENV: lab
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: redis
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
DB_CONNECT_TIMEOUT: "5"
DB_POOL_MIN: "1"
DB_POOL_MAX: "8"
REDIS_SOCKET_TIMEOUT: "3"
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
RUN_MIGRATIONS: "false"
services:
postgres:
image: postgres:16.4-bookworm
environment:
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
POSTGRES_DB: messenger
secrets:
- postgres_password
volumes:
- pg_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
restart: unless-stopped
mem_limit: 512m
cpus: 0.50
redis:
image: redis:7.4.1-bookworm
command:
- redis-server
- --appendonly
- "yes"
- --appendfsync
- everysec
- --dir
- /data
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
restart: unless-stopped
mem_limit: 256m
cpus: 0.25
migrate:
build:
context: .
dockerfile: Dockerfile
command: ["python", "-m", "app.migrate"]
environment:
<<: *api-env
RUN_MIGRATIONS: "true"
secrets:
- database_url
- cache_url
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
restart: "no"
mem_limit: 256m
cpus: 0.25
api:
build:
context: .
dockerfile: Dockerfile
environment:
<<: *api-env
secrets:
- database_url
- cache_url
depends_on:
migrate:
condition: service_completed_successfully
postgres:
condition: service_healthy
redis:
condition: service_healthy
# No host ports — only via lb. Scale with: --scale api=2
expose:
- "8080"
healthcheck:
test:
[
"CMD",
"python",
"-c",
"import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)",
]
interval: 2s
timeout: 2s
start_period: 15s
retries: 10
restart: unless-stopped
stop_grace_period: 10s
mem_limit: 384m
cpus: 0.50
lb:
image: haproxy:2.9.7-bookworm
ports:
- "127.0.0.1:8080:8080"
volumes:
- ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
depends_on:
api:
condition: service_healthy
healthcheck:
test: ["CMD", "haproxy", "-c", "-f", "/usr/local/etc/haproxy/haproxy.cfg"]
interval: 10s
timeout: 3s
retries: 3
restart: unless-stopped
mem_limit: 128m
cpus: 0.25
volumes:
pg_data:
redis_data:
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
Binary file not shown.
BIN
View File
Binary file not shown.
Binary file not shown.
Binary file not shown.
+37
View File
@@ -0,0 +1,37 @@
global
maxconn 4096
log stdout format raw local0
defaults
mode http
log global
option httplog
option http-server-close
timeout connect 3s
timeout client 30s
timeout server 30s
timeout check 2s
retries 2
resolvers docker
nameserver dns1 127.0.0.11:53
resolve_retries 3
timeout resolve 1s
timeout retry 1s
hold other 5s
hold refused 5s
hold nx 5s
hold timeout 5s
hold valid 5s
hold obsolete 5s
frontend fe_http
bind *:8080
default_backend be_api
backend be_api
balance roundrobin
option httpchk GET /health/ready
http-check expect status 200
# Dynamic API tasks via Compose DNS; drop failed backends within ~4s (inter 2s * fall 2).
server-template api- 8 api:8080 check resolvers docker init-addr last,libc,none resolve-prefer ipv4 inter 2s fall 2 rise 1
+37
View File
@@ -0,0 +1,37 @@
-- Lab2 schema: users, chats, membership, messages.
CREATE TABLE IF NOT EXISTS users (
id UUID PRIMARY KEY,
username TEXT NOT NULL,
display_name TEXT NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE UNIQUE INDEX IF NOT EXISTS users_username_uq ON users (username);
CREATE TABLE IF NOT EXISTS chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE IF NOT EXISTS chat_members (
chat_id UUID NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users (id),
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX IF NOT EXISTS chat_members_user_id_idx ON chat_members (user_id);
CREATE TABLE IF NOT EXISTS messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users (id),
text TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
-- Keyset history: (chat_id, created_at, id) — without full table scan per page.
CREATE INDEX IF NOT EXISTS messages_chat_created_id_idx
ON messages (chat_id, created_at, id);
+15
View File
@@ -0,0 +1,15 @@
-- Shared idempotency for POST messages across API replicas.
CREATE TABLE IF NOT EXISTS idempotency_keys (
user_id UUID NOT NULL REFERENCES users (id),
method TEXT NOT NULL,
path TEXT NOT NULL,
idem_key TEXT NOT NULL,
request_hash TEXT NOT NULL,
response_status INT NOT NULL,
response_body JSONB NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
PRIMARY KEY (user_id, method, path, idem_key)
);
CREATE INDEX IF NOT EXISTS idempotency_keys_created_at_idx
ON idempotency_keys (created_at);
+7
View File
@@ -0,0 +1,7 @@
fastapi==0.115.6
uvicorn==0.32.1
pydantic==2.10.3
starlette==0.41.3
psycopg[binary,pool]==3.2.3
redis==5.2.1
argon2-cffi==23.1.0
+13
View File
@@ -0,0 +1,13 @@
# Creates local synthetic secrets for compose (never commit secrets/).
$ErrorActionPreference = "Stop"
$root = Split-Path -Parent $PSScriptRoot
$secrets = Join-Path $root "secrets"
New-Item -ItemType Directory -Force -Path $secrets | Out-Null
$password = "lab2-pg-pass-" + [guid]::NewGuid().ToString("N").Substring(0, 12)
Set-Content -Path (Join-Path $secrets "postgres_password") -Value $password -NoNewline
# URL for the API container (service DNS name "postgres" / "redis").
$dbUrl = "postgresql://messenger:${password}@postgres:5432/messenger"
Set-Content -Path (Join-Path $secrets "database_url") -Value $dbUrl -NoNewline
Set-Content -Path (Join-Path $secrets "cache_url") -Value "redis://redis:6379/0" -NoNewline
Write-Host "Wrote secrets/postgres_password, secrets/database_url, secrets/cache_url"
+9
View File
@@ -0,0 +1,9 @@
#!/bin/sh
set -eu
ROOT="$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)"
mkdir -p "$ROOT/secrets"
PASSWORD="lab2-pg-pass-$(openssl rand -hex 6)"
printf '%s' "$PASSWORD" > "$ROOT/secrets/postgres_password"
printf '%s' "postgresql://messenger:${PASSWORD}@postgres:5432/messenger" > "$ROOT/secrets/database_url"
printf '%s' "redis://redis:6379/0" > "$ROOT/secrets/cache_url"
echo "Wrote secrets/postgres_password, secrets/database_url, secrets/cache_url"
+4
View File
@@ -0,0 +1,4 @@
@echo off
cd /d "%~dp0.."
docker compose --env-file .env restart
exit /b %ERRORLEVEL%
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
set -eu
# Restart LB, API replicas and state stores without removing volumes.
cd "$(dirname "$0")/.."
docker compose --env-file .env restart
exit 0
+5
View File
@@ -0,0 +1,5 @@
@echo off
REM Start any stopped API containers after failover demo.
cd /d "%~dp0.."
docker compose --env-file .env start api
exit /b %ERRORLEVEL%
+17
View File
@@ -0,0 +1,17 @@
@echo off
setlocal
cd /d "%~dp0.."
if "%TARGET_INSTANCE_ID%"=="" (
echo TARGET_INSTANCE_ID required 1>&2
exit /b 1
)
for /f %%i in ('docker compose --env-file .env ps -q api') do (
for /f %%h in ('docker inspect -f "{{.Config.Hostname}}" %%i') do (
if "%%h"=="%TARGET_INSTANCE_ID%" (
docker stop %%i >nul
exit /b 0
)
)
)
echo API replica not found for TARGET_INSTANCE_ID 1>&2
exit /b 1
+18
View File
@@ -0,0 +1,18 @@
#!/bin/sh
set -eu
# Stop ONE API replica matching TARGET_INSTANCE_ID (= X-Instance-Id = container hostname).
# Leave it stopped; do not touch DB/LB/volumes. Return quickly.
cd "$(dirname "$0")/.."
: "${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID required}"
for id in $(docker compose --env-file .env ps -q api); do
[ -n "$id" ] || continue
host=$(docker inspect -f '{{.Config.Hostname}}' "$id")
if [ "$host" = "$TARGET_INSTANCE_ID" ]; then
docker stop "$id" >/dev/null
exit 0
fi
done
printf '%s\n' "API replica not found for TARGET_INSTANCE_ID" >&2
exit 1
+144
View File
@@ -0,0 +1,144 @@
#!/usr/bin/env python3
"""Own lab3 tests (grade 4): multi-instance, idempotency, failover helpers."""
import threading
import uuid
from concurrent.futures import ThreadPoolExecutor
from urllib.parse import quote
from client import Client, Failure, arguments, check, run
def test_multiple_instance_ids(c: Client):
alice = c.user("inst")
seen = set()
for _ in range(40):
seen.add(
c.call("GET", "/api/v1/users/me", actor=alice, schema="User")["headers"][
"X-Instance-Id"
]
)
check(len(seen) >= 2, "expected >=2 X-Instance-Id via LB, got %r" % (seen,))
print("PASS: observed instances %s" % sorted(seen))
def test_idempotency_replay(c: Client):
alice = c.user("idem")
chat = c.call(
"POST",
"/api/v1/chats",
201,
actor=alice,
body={"title": "Idem", "member_ids": [alice["id"]]},
schema="Chat",
)["json"]
key = uuid.uuid4().hex
first = c.message(alice, chat, "same", key=key)["json"]
second = c.message(alice, chat, "same", key=key)["json"]
check(first == second, "idempotent replay must return same message")
c.call(
"POST",
"/api/v1/chats/" + chat["id"] + "/messages",
409,
actor=alice,
body={"text": "other"},
headers={"Idempotency-Key": key},
schema="Error",
)
def test_idempotency_concurrent(c: Client):
alice = c.user("raceidem")
chat = c.call(
"POST",
"/api/v1/chats",
201,
actor=alice,
body={"title": "RaceIdem", "member_ids": [alice["id"]]},
schema="Chat",
)["json"]
key = uuid.uuid4().hex
text = "concurrent-" + key
barrier = threading.Barrier(8)
results = []
def worker():
local = Client(c.base, timeout=20)
barrier.wait()
try:
msg = local.message(alice, chat, text, key=key)["json"]
results.append(msg["id"])
except Failure as exc:
results.append(str(exc))
with ThreadPoolExecutor(max_workers=8) as pool:
list(pool.map(lambda _: worker(), range(8)))
ids = [r for r in results if isinstance(r, str) and len(r) == 36]
check(len(ids) == 8, "all concurrent calls must succeed, got %r" % (results,))
check(len(set(ids)) == 1, "expected exactly one message id, got %r" % (set(ids),))
def test_missing_idempotency_key(c: Client):
alice = c.user("nokey")
chat = c.call(
"POST",
"/api/v1/chats",
201,
actor=alice,
body={"title": "NoKey", "member_ids": [alice["id"]]},
schema="Chat",
)["json"]
c.call(
"POST",
"/api/v1/chats/" + chat["id"] + "/messages",
400,
actor=alice,
body={"text": "без ключа"},
schema="Error",
)
def test_pagination(c: Client):
alice = c.user("page")
chat = c.call(
"POST",
"/api/v1/chats",
201,
actor=alice,
body={"title": "Pages", "member_ids": [alice["id"]]},
schema="Chat",
)["json"]
for i in range(5):
c.message(alice, chat, "m-%d" % i)
path = "/api/v1/chats/" + chat["id"] + "/messages"
collected = []
cursor = None
while True:
q = path + "?limit=2"
if cursor:
q += "&cursor=" + quote(cursor, safe="")
page = c.call("GET", q, actor=alice, schema="MessagePage")["json"]
collected.extend(page["items"])
cursor = page["next_cursor"]
if cursor is None:
break
check(len(collected) == 5, "expected 5 messages")
def main():
args = arguments("Own lab3 tests")
c = Client(args.base_url, args.ca_file, timeout=20)
c.call("GET", "/health/ready", schema="Health")
test_multiple_instance_ids(c)
test_idempotency_replay(c)
print("PASS: idempotency replay/conflict")
test_idempotency_concurrent(c)
print("PASS: concurrent idempotency")
test_missing_idempotency_key(c)
print("PASS: missing Idempotency-Key -> 400")
test_pagination(c)
print("PASS: pagination")
print("PASS: all own lab3 tests")
if __name__ == "__main__":
run(main)