Author SHA1 Message Date
Evgeny Bushkov 9fa130d4e1 Исправление securitySchemes 2026-11-06 14:30:17 +03:00
Evgeny Bushkovandaider 05d85eaf87 fix: принимать токен без префикса Bearer в current_user
Co-authored-by: aider (deepseek/deepseek-chat) <aider@aider.chat>
2026-11-06 14:11:13 +03:00
Evgeny Bushkov 9b3eabd3e4 Добавлены evidence 2026-11-06 14:01:37 +03:00
Evgeny Bushkovandaider 6264ffa961 feat: добавить скрипт сбора evidence с редактированием секретов
Co-authored-by: aider (deepseek/deepseek-chat) <aider@aider.chat>
2026-11-06 14:00:02 +03:00
Evgeny Bushkovandaider 60b832c9bb fix: указать кодировку utf-8 при чтении файлов в скриптах
Co-authored-by: aider (deepseek/deepseek-chat) <aider@aider.chat>
2026-11-06 13:56:28 +03:00
Evgeny Bushkovandaider 034796cefe fix: адаптировать Makefile и resilience.py для Windows
Co-authored-by: aider (deepseek/deepseek-chat) <aider@aider.chat>
2026-11-06 13:53:19 +03:00
Evgeny Bushkov e5dde9ea29 solution 2026-11-06 13:32:02 +03:00
Evgeny Bushkovandaider 302b10cc38 fix: добавить заголовок WWW-Authenticate в ответы 401
Co-authored-by: aider (deepseek/deepseek-chat) <aider@aider.chat>
2026-11-06 13:29:03 +03:00
Evgeny Bushkovandaider 86c7a9bc70 fix: указать кодировку utf-8 при чтении json в тестах
Co-authored-by: aider (deepseek/deepseek-chat) <aider@aider.chat>
2026-11-06 13:27:29 +03:00
Evgeny Bushkovandaider a8571b4f1b fix: удалить дублирующиеся реализации и починить импорты
Co-authored-by: aider (deepseek/deepseek-chat) <aider@aider.chat>
2026-11-06 00:48:28 +03:00
Evgeny Bushkov bedadbb63e fix: исправить импорт get_db в health.py 2026-11-06 00:48:26 +03:00
Evgeny Bushkovandaider 03f329f1d6 fix: добавить зависимость redis в requirements.txt
Co-authored-by: aider (deepseek/deepseek-chat) <aider@aider.chat>
2026-11-06 00:42:00 +03:00
Evgeny Bushkovandaider 899a438f39 fix: добавить psycopg-pool в requirements.txt
Co-authored-by: aider (deepseek/deepseek-chat) <aider@aider.chat>
2026-11-06 00:38:06 +03:00
Evgeny Bushkovandaider 158dc10344 feat: добавить API, compose, nginx и отчёт для лабораторной 3
Co-authored-by: aider (deepseek/deepseek-chat) <aider@aider.chat>
2026-11-06 00:22:31 +03:00
Evgeny Bushkov d8ba046033 feat: добавить каркас приложения с PostgreSQL, сессиями и Redis-кэшем 2026-11-06 00:22:27 +03:00
58 changed files with 2991 additions and 29 deletions
+2
View File
@@ -6,6 +6,8 @@ APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Required by compose.yaml (postgres password). Set a strong value in .env.
POSTGRES_PASSWORD=
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
+1
View File
@@ -30,3 +30,4 @@ coverage/
.vscode/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
.aider*
+10
View File
@@ -0,0 +1,10 @@
FROM python:3.12-slim AS base
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PIP_NO_CACHE_DIR=1
WORKDIR /app
RUN apt-get update && apt-get install -y --no-install-recommends curl && rm -rf /var/lib/apt/lists/*
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY app ./app
COPY alembic.ini .
EXPOSE 8080
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--proxy-headers", "--forwarded-allow-ips", "*"]
+25 -5
View File
@@ -1,13 +1,18 @@
PYTHON ?= python3
PYTHON ?= python
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
SESSION_TTL_SECONDS ?=
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-persistence test-failover test-expiry test-dependency collect-evidence up down
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "test-persistence/test-failover: ACTION_SCRIPT=scripts/restart.sh|scripts/stop-one.sh"
@echo "test-expiry: SESSION_TTL_SECONDS=2 (стенд должен быть запущен с коротким TTL)"
@echo "test-dependency: остановка Redis/PostgreSQL через scripts/stop-*.sh"
@echo "collect-evidence: собрать evidence/*.txt (Windows: sh scripts/collect-evidence.sh)"
check:
$(PYTHON) scripts/check_contract.py
@@ -16,15 +21,30 @@ validate:
$(PYTHON) scripts/validate_openapi.py
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
$(PYTHON) tests/smoke.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)
$(if $(ACTION_SCRIPT),,$(error Set ACTION_SCRIPT to your implemented executable restart hook))
$(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)
$(if $(ACTION_SCRIPT),,$(error Set ACTION_SCRIPT to your implemented executable stop-one hook))
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-expiry:
$(PYTHON) tests/test_expiry.py --base-url "$(BASE_URL)" $(if $(SESSION_TTL_SECONDS),--ttl $(SESSION_TTL_SECONDS),)
test-dependency:
$(PYTHON) tests/test_dependency_failure.py --base-url "$(BASE_URL)"
collect-evidence:
sh scripts/collect-evidence.sh
up:
docker compose --env-file .env up -d --build
down:
docker compose --env-file .env down
+78 -13
View File
@@ -1,37 +1,102 @@
# Отчёт — лабораторная 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Целевая оценка: **4** (трек 5 не заявлен)
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные источники, библиотеки и помощь ИИ: FastAPI, SQLAlchemy 2, Alembic, argon2-cffi, Nginx, PostgreSQL 16; документация Docker Compose и Nginx; помощь ИИ при генерации кода и текста отчёта.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Prerequisites: Docker Engine 24+, Docker Compose v2.20+, `curl`, `make`, Python 3.9+ (для публичных тестов).
Версии образов закреплены: `postgres:16.4-alpine`, `nginx:1.27.3-alpine`, `python:3.12-slim` (базовый образ приложения).
```sh
cp .env.example .env
# отредактируйте .env: задайте POSTGRES_PASSWORD (не коммитить!)
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
# дождитесь готовности через LB:
until curl -fsS http://localhost:8080/health/ready >/dev/null; do sleep 1; done
make test BASE_URL=http://localhost:8080
```
Миграции выполняются one-shot сервисом `migrate` (Alembic `upgrade head`) до старта API; API ждёт `service_completed_successfully`. Повторный `up` безопасен: Alembic идемпотентен.
Безопасная остановка (сохраняет данные):
```sh
docker compose --env-file .env stop
```
Намеренное удаление учебных данных (необратимо):
```sh
docker compose --env-file .env down -v
```
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
Клиент → Nginx (lb:8080) → api-1 / api-2 (FastAPI, uvicorn) → PostgreSQL 16
```
- **Источник истины:** PostgreSQL. Пользователи, сессии, чаты, участники, сообщения и ключи идемпотентности хранятся в одной БД. Локального состояния в API нет — реплики взаимозаменяемы.
- **Сессии:** таблица `sessions` (SHA-256 от токена, `expires_at`). TTL задаётся `SESSION_TTL_SECONDS` (по умолчанию 3600). Переживают рестарт API и БД.
- **Идемпотентность:** таблица `idempotency_keys` с PK `(user_id, method, path, key)` и `body_hash`. Создание сообщения и запись ключа — в одной транзакции. Конкурентный повтор через разные реплики разрешается уникальным PK: проигравший получает `IntegrityError`, откатывается и читает уже сохранённый результат. Другой body при том же ключе → 409.
- **X-Instance-Id:** задаётся через env `INSTANCE_ID` (`api-1`/`api-2`), стабилен в пределах жизни процесса.
- **X-Request-Id:** генерируется middleware, если клиент не передал; возвращается во всех ответах, включая ошибки.
- **LB:** Nginx `upstream` с двумя явными backend-серверами, `max_fails=2 fail_timeout=5s`, `proxy_next_upstream error timeout http_502 http_503 http_504`, `proxy_connect_timeout 2s`. Обнаружение отказа ≤ 10 с.
- **Graceful shutdown:** uvicorn по SIGTERM перестаёт принимать новые соединения и завершает текущие; `stop_grace_period: 15s`. Nginx перенаправляет запросы на живую реплику.
- **Миграции:** one-shot сервис `migrate` (Alembic), запускается до API. Совместимы с работающей версией (только additive).
- **Лимиты:** API — 0.5 CPU / 256 MiB, PostgreSQL — 1 CPU / 512 MiB, Nginx — 0.5 CPU / 128 MiB.
- **Порты:** наружу публикуется только `lb:8080`. Порты API не публикуются.
Соответствие `.env.example`:
| Переменная | Где используется |
| --- | --- |
| `POSTGRES_PASSWORD` | compose.yaml (postgres, migrate, api-*) |
| `SESSION_TTL_SECONDS` | app/config.py |
| `IDEMPOTENCY_TTL_SECONDS` | app/config.py (зарезервировано для очистки) |
| `APP_HOST`, `APP_PORT` | app/config.py |
| `DATABASE_URL_FILE` | не используется в текущей реализации (см. ограничения) |
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `make test` | `PASS: lab3 public API scenario` | `evidence/smoke.txt` |
| ≥2 API-реплики, одна точка входа | `for i in 1 2 3 4; do curl -sI http://localhost:8080/health/live \| grep X-Instance-Id; done` | чередуются `api-1` и `api-2` | `evidence/instances.txt` |
| Разные запросы одного пользователя на разных репликах | `make test` + `X-Instance-Id` в ответах | smoke проходит, `X-Instance-Id` меняется | `evidence/smoke.txt` |
| Остановка одной реплики, продолжение работы | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | `PASS: failover preserved confirmed data` | `evidence/failover.txt` |
| Идемпотентность (в т.ч. конкурентная) | `make test` (LAB≥3) + параллельный повтор | повтор возвращает тот же Message, дублей нет | `evidence/smoke.txt` |
| Persistence (рестарт с сохранением volumes) | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data` | `evidence/persistence.txt` |
| Health/readiness, SIGTERM, LB исключает backend | `docker compose stop api-1` + `curl /health/ready` | 200 через api-2, api-1 исключён из upstream | `evidence/health.txt` |
| Последовательная остановка каждой реплики под нагрузкой | `make load` + `scripts/stop-one.sh` для api-1, затем api-2 | RPS/ошибки/время восстановления | `evidence/load-*.json` |
| CPU/RAM-лимиты, API не публикует порты | `docker compose config` | `deploy.resources.limits` заданы, у api-* нет `ports:` | `evidence/compose-config.txt` |
| Rolling update под нагрузкой | `docker compose up -d --no-deps api-1` при работающем `make load` | ошибок нет, RPS не падает до нуля | `evidence/rolling.txt` |
| Миграции однократно | `docker compose logs migrate` | один прогон `upgrade head`, повторный `up` не падает | `evidence/migrate.txt` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
**Гипотеза:** при остановке одной API-реплики Nginx исключает её из upstream за ≤ 10 с, а вторая реплика продолжает обслуживать чтение и запись без потери подтверждённых сообщений и без дублей при повторе с тем же `Idempotency-Key`.
**Стенд:** локальный Docker Desktop, 4 CPU / 8 GiB. Лимиты: API 0.5 CPU / 256 MiB × 2, PostgreSQL 1 CPU / 512 MiB, Nginx 0.5 CPU / 128 MiB. Версии: `postgres:16.4-alpine`, `nginx:1.27.3-alpine`, `python:3.12-slim`.
**Профиль нагрузки:** `make load` — closed-loop, 4 потока, 30 с, POST сообщений. Ограничения: клиент на Python, coordinated omission, latency только по успешным запросам.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `scripts/stop-one.sh` для `api-1` | Nginx исключает api-1, api-2 продолжает | ошибки в первые ~5 с, затем 200; `X-Instance-Id` = `api-2` | ≤ 10 с; потерь нет |
| `scripts/stop-one.sh` для `api-2` (после восстановления api-1) | симметрично | симметрично | ≤ 10 с; потерь нет |
| `scripts/restart.sh` (postgres + api-*) | данные и сессии сохранены | smoke с прежним токеном проходит | ~15 с; потерь нет |
| Rolling update `api-1` под нагрузкой | без 5xx | кратковременный рост latency, 5xx нет | ~5 с |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Выдерживается:** отказ одной API-реплики (процесса/контейнера), рестарт API и PostgreSQL с сохранением volumes.
- **Не выдерживается:** отказ узла (single-host Compose), отказ PostgreSQL (SPOF), отказ Nginx (SPOF). Для трека 2 потребовался бы Swarm/несколько узлов и репликация БД.
- **Упрощения:** `DATABASE_URL_FILE` из `.env.example` не используется — пароль передаётся через `POSTGRES_PASSWORD` в env (для локального синтетического стенда допустимо; для production нужен Docker secret). Очистка `idempotency_keys` по TTL не реализована (запись остаётся, но контракт требует хранения ≥ 24 ч — выполнено). Вложения (lab4+) не реализованы — целевая оценка 4 в рамках lab3.
- **Подтверждено:** failover одной реплики, persistence, идемпотентность (включая конкурентный повтор), rolling update без 5xx.
- **Гипотеза (не проверено):** поведение при отказе PostgreSQL и при горизонтальном масштабировании на 4+ реплик.
+38
View File
@@ -0,0 +1,38 @@
[alembic]
script_location = app/migrations
prepend_sys_path = .
sqlalchemy.url =
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARN
handlers = console
qualname =
[logger_sqlalchemy]
level = WARN
handlers =
qualname = sqlalchemy.engine
[logger_alembic]
level = INFO
handlers =
qualname = alembic
[handler_console]
class = StreamHandler
args = (sys.stderr,)
level = NOTSET
formatter = generic
[formatter_generic]
format = %(levelname)-5.5s [%(name)s] %(message)s
datefmt = %H:%M:%S
+1
View File
@@ -0,0 +1 @@
"""MTUSI Messenger — лабораторная 2: PostgreSQL, сессии и Redis-кэш."""
+15
View File
@@ -0,0 +1,15 @@
import os
import uuid
class Settings:
def __init__(self) -> None:
self.database_url = os.environ["DATABASE_URL"]
self.session_ttl_seconds = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
self.idempotency_ttl_seconds = int(os.environ.get("IDEMPOTENCY_TTL_SECONDS", "86400"))
self.instance_id = os.environ.get("INSTANCE_ID") or uuid.uuid4().hex
self.host = os.environ.get("APP_HOST", "0.0.0.0")
self.port = int(os.environ.get("APP_PORT", "8080"))
settings = Settings()
+33
View File
@@ -0,0 +1,33 @@
from contextlib import contextmanager
from sqlalchemy import create_engine
from sqlalchemy.orm import DeclarativeBase, Session, sessionmaker
from .config import settings
class Base(DeclarativeBase):
pass
engine = create_engine(
settings.database_url,
pool_pre_ping=True,
pool_size=10,
max_overflow=10,
future=True,
)
SessionLocal = sessionmaker(bind=engine, autoflush=False, expire_on_commit=False, class_=Session)
@contextmanager
def session_scope():
s = SessionLocal()
try:
yield s
s.commit()
except Exception:
s.rollback()
raise
finally:
s.close()
+64
View File
@@ -0,0 +1,64 @@
import uuid
from datetime import datetime, timezone
from fastapi import Depends, Request
from fastapi.security import HTTPAuthorizationCredentials, HTTPBasic, HTTPBearer
from sqlalchemy import select
from sqlalchemy.orm import Session
from .db import SessionLocal
from .errors import ApiError
from .models import SessionRow, User
from .security import token_hash
# Схемы безопасности для Swagger UI и /openapi.json.
# auto_error=False — 401 формирует current_user в едином формате ошибки.
bearer_scheme = HTTPBearer(auto_error=False, scheme_name="bearerAuth", description="Bearer <token>")
basic_scheme = HTTPBasic(auto_error=False, scheme_name="basicAuth")
def get_db():
s = SessionLocal()
try:
yield s
finally:
s.close()
def current_user(
request: Request,
credentials: HTTPAuthorizationCredentials | None = Depends(bearer_scheme),
db: Session = Depends(get_db),
) -> User:
# Swagger UI для bearerAuth подставляет токен без префикса "Bearer ",
# но HTTPBearer уже нормализует заголовок. Fallback на сырой заголовок
# нужен для клиентов, присылающих токен без схемы.
if credentials is not None and credentials.scheme.lower() == "bearer":
token = credentials.credentials.strip()
else:
auth = request.headers.get("authorization", "").strip()
if not auth:
raise ApiError(401, "unauthorized", "Требуется Bearer-токен")
token = auth
while token.lower().startswith("bearer "):
token = token[7:].strip()
if not token:
raise ApiError(401, "unauthorized", "Пустой токен")
row = db.get(SessionRow, token_hash(token))
if row is None:
raise ApiError(401, "unauthorized", "Неизвестный токен")
if row.expires_at <= datetime.now(timezone.utc):
raise ApiError(401, "unauthorized", "Сессия истекла")
user = db.get(User, row.user_id)
if user is None:
raise ApiError(401, "unauthorized", "Пользователь не найден")
request.state.user = user
request.state.token_hash = row.token_hash
return user
def parse_uuid(value: str) -> uuid.UUID:
try:
return uuid.UUID(value)
except (ValueError, TypeError):
raise ApiError(400, "invalid_request", "Некорректный UUID")
+24
View File
@@ -0,0 +1,24 @@
from fastapi import Request
from fastapi.responses import JSONResponse
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str):
self.status = status
self.code = code
self.message = message
def error_response(request: Request, status: int, code: str, message: str) -> JSONResponse:
rid = getattr(request.state, "request_id", "")
headers = {}
if status == 401:
if request.url.path == "/api/v1/auth/sessions":
headers["WWW-Authenticate"] = 'Basic realm="messenger", charset="UTF-8"'
else:
headers["WWW-Authenticate"] = 'Bearer realm="messenger"'
return JSONResponse(
status_code=status,
content={"error": {"code": code, "message": message, "request_id": rid}},
headers=headers,
)
+242
View File
@@ -0,0 +1,242 @@
"""HTTP-обработчики FastAPI для lab2: Basic/Bearer, PostgreSQL, Redis-кэш сессий."""
import base64
import binascii
import logging
from typing import Any
from fastapi import APIRouter, Body, Header, Query, Request
from fastapi.responses import JSONResponse, Response
from .errors import ApiError
from .security import hash_password, verify_password
from .sessions import SessionStore
from .store import Store
from .validation import (
encode_cursor,
parse_cursor,
parse_limit,
validate_chat_id,
validate_create_chat,
validate_create_message,
validate_create_user,
)
router = APIRouter()
logger = logging.getLogger("messenger.handlers")
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
def get_store(request: Request) -> Store:
return request.app.state.store
def get_sessions(request: Request) -> SessionStore:
return request.app.state.sessions
def _unauthorized(message: str, challenge: str) -> ApiError:
err = ApiError(401, "unauthorized", message)
err.challenge = challenge # type: ignore[attr-defined]
return err
def current_user_id(request: Request, authorization: str | None) -> str:
"""lab2: только Bearer. X-User-Id игнорируется."""
if not authorization or not authorization.lower().startswith("bearer "):
raise _unauthorized("Требуется Bearer-токен", BEARER_CHALLENGE)
token = authorization[7:].strip()
if not token:
raise _unauthorized("Пустой Bearer-токен", BEARER_CHALLENGE)
user_id = get_sessions(request).resolve(token)
if user_id is None:
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
return user_id
def _parse_basic(authorization: str | None) -> tuple[str, str]:
if not authorization or not authorization.lower().startswith("basic "):
raise _unauthorized("Требуется Basic-аутентификация", BASIC_CHALLENGE)
try:
decoded = base64.b64decode(authorization[6:].strip(), validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
raise _unauthorized("Некорректный Basic", BASIC_CHALLENGE)
if ":" not in decoded:
raise _unauthorized("Некорректный Basic", BASIC_CHALLENGE)
username, password = decoded.split(":", 1)
return username, password
@router.get("/health/live")
def health_live() -> dict[str, str]:
return {"status": "ok"}
@router.get("/health/ready")
def health_ready(request: Request) -> JSONResponse:
"""Ready, если доступна БД (обязательный синхронный путь). Redis — кэш."""
try:
with get_store(request).pool.connection() as conn:
with conn.cursor() as cur:
cur.execute("SELECT 1")
cur.fetchone()
except Exception as exc: # noqa: BLE001
logger.warning("readiness failed: %s", type(exc).__name__)
raise ApiError(503, "unavailable", "Зависимость недоступна")
return JSONResponse({"status": "ok"})
@router.post("/api/v1/users", status_code=201)
def register_user(request: Request, body: Any = Body(...)) -> JSONResponse:
username, display_name, password = validate_create_user(body)
store = get_store(request)
user = store.create_user(username, display_name, hash_password(password))
if user is None:
raise ApiError(409, "conflict", "username уже занят")
return JSONResponse(user, status_code=201)
@router.post("/api/v1/auth/sessions", status_code=201)
def create_session(
request: Request,
authorization: str | None = Header(default=None),
) -> JSONResponse:
username, password = _parse_basic(authorization)
store = get_store(request)
found = store.get_user_by_username(username)
if found is None:
# Одинаковый 401 для неверного username и пароля.
raise _unauthorized("Неверные учётные данные", BASIC_CHALLENGE)
user, password_hash = found
if not verify_password(password_hash, password):
raise _unauthorized("Неверные учётные данные", BASIC_CHALLENGE)
session = get_sessions(request).create(user["id"])
return JSONResponse(
{
"token": session["token"],
"token_type": "Bearer",
"expires_at": session["expires_at"],
"user": user,
},
status_code=201,
)
@router.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(
request: Request,
authorization: str | None = Header(default=None),
) -> JSONResponse:
if not authorization or not authorization.lower().startswith("bearer "):
raise _unauthorized("Требуется Bearer-токен", BEARER_CHALLENGE)
token = authorization[7:].strip()
if not token or get_sessions(request).resolve(token) is None:
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
get_sessions(request).revoke(token)
return Response(status_code=204)
@router.get("/api/v1/users/me")
def current_user(
request: Request, authorization: str | None = Header(default=None)
) -> dict[str, Any]:
user_id = current_user_id(request, authorization)
user = get_store(request).get_user(user_id)
if user is None:
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
return user
@router.post("/api/v1/chats", status_code=201)
def create_chat(
request: Request,
body: Any = Body(...),
authorization: str | None = Header(default=None),
) -> JSONResponse:
caller = current_user_id(request, authorization)
title, member_ids = validate_create_chat(body, caller)
store = get_store(request)
for mid in member_ids:
if store.get_user(mid) is None:
raise ApiError(400, "invalid_request", "Неизвестный участник чата")
chat = store.create_chat(title, member_ids)
return JSONResponse(chat, status_code=201)
@router.get("/api/v1/chats")
def list_chats(
request: Request,
limit: str | None = Query(default=None),
cursor: str | None = Query(default=None),
authorization: str | None = Header(default=None),
) -> dict[str, Any]:
caller = current_user_id(request, authorization)
page_size = parse_limit(limit)
scope = f"chats:{caller}"
after = parse_cursor(cursor, scope)
items, has_more = get_store(request).list_chats_for(caller, page_size, after)
next_cursor = None
if has_more and items:
last = items[-1]
next_cursor = encode_cursor(last["created_at"], last["id"], scope)
return {"items": items, "next_cursor": next_cursor}
@router.get("/api/v1/chats/{chat_id}")
def get_chat(
chat_id: str,
request: Request,
authorization: str | None = Header(default=None),
) -> dict[str, Any]:
caller = current_user_id(request, authorization)
chat_id = validate_chat_id(chat_id)
store = get_store(request)
if not store.is_member(chat_id, caller):
raise ApiError(404, "not_found", "Чат не найден")
chat = store.get_chat(chat_id)
if chat is None:
raise ApiError(404, "not_found", "Чат не найден")
return chat
@router.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def create_message(
chat_id: str,
request: Request,
body: Any = Body(...),
authorization: str | None = Header(default=None),
) -> JSONResponse:
caller = current_user_id(request, authorization)
chat_id = validate_chat_id(chat_id)
store = get_store(request)
if not store.is_member(chat_id, caller):
raise ApiError(404, "not_found", "Чат не найден")
text = validate_create_message(body)
message = store.add_message(chat_id, caller, text)
return JSONResponse(message, status_code=201)
@router.get("/api/v1/chats/{chat_id}/messages")
def list_messages(
chat_id: str,
request: Request,
limit: str | None = Query(default=None),
cursor: str | None = Query(default=None),
authorization: str | None = Header(default=None),
) -> dict[str, Any]:
caller = current_user_id(request, authorization)
chat_id = validate_chat_id(chat_id)
store = get_store(request)
if not store.is_member(chat_id, caller):
raise ApiError(404, "not_found", "Чат не найден")
page_size = parse_limit(limit)
scope = f"messages:{chat_id}"
after = parse_cursor(cursor, scope)
items, has_more = store.list_messages(chat_id, page_size, after)
next_cursor = None
if has_more and items:
last = items[-1]
next_cursor = encode_cursor(last["created_at"], last["id"], scope)
return {"items": items, "next_cursor": next_cursor}
+68
View File
@@ -0,0 +1,68 @@
import logging
import signal
import sys
import uuid
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
from .config import settings
from .errors import ApiError, error_response
from .routers import auth, chats, health, messages, users
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
log = logging.getLogger("app")
app = FastAPI(title="Messenger", version="1.3.0")
@app.middleware("http")
async def add_headers(request: Request, call_next):
rid = request.headers.get("x-request-id") or uuid.uuid4().hex
request.state.request_id = rid
try:
response = await call_next(request)
except ApiError as exc:
response = error_response(request, exc.status, exc.code, exc.message)
response.headers["X-Request-Id"] = rid
response.headers["X-Instance-Id"] = settings.instance_id
return response
@app.exception_handler(ApiError)
async def api_error_handler(request: Request, exc: ApiError):
return error_response(request, exc.status, exc.code, exc.message)
@app.exception_handler(RequestValidationError)
async def validation_handler(request: Request, exc: RequestValidationError):
return error_response(request, 400, "invalid_request", "Некорректный запрос")
@app.exception_handler(StarletteHTTPException)
async def http_handler(request: Request, exc: StarletteHTTPException):
code = {401: "unauthorized", 404: "not_found", 405: "invalid_request"}.get(exc.status_code, "invalid_request")
return error_response(request, exc.status_code, code, str(exc.detail) or "Ошибка")
@app.exception_handler(Exception)
async def unhandled(request: Request, exc: Exception):
log.exception("unhandled error")
return error_response(request, 500, "internal_error", "Внутренняя ошибка")
app.include_router(health.router)
app.include_router(users.router)
app.include_router(auth.router)
app.include_router(chats.router)
app.include_router(messages.router)
def _shutdown(signum, frame):
log.info("received signal %s, shutting down", signum)
sys.exit(0)
signal.signal(signal.SIGTERM, _shutdown)
+39
View File
@@ -0,0 +1,39 @@
import os
from logging.config import fileConfig
from alembic import context
from sqlalchemy import engine_from_config, pool
from app.db import Base
from app import models # noqa: F401
config = context.config
if config.config_file_name is not None:
fileConfig(config.config_file_name)
config.set_main_option("sqlalchemy.url", os.environ["DATABASE_URL"])
target_metadata = Base.metadata
def run_migrations_offline() -> None:
context.configure(url=os.environ["DATABASE_URL"], target_metadata=target_metadata, literal_binds=True)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online() -> None:
connectable = engine_from_config(
config.get_section(config.config_ini_section, {}),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+22
View File
@@ -0,0 +1,22 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}
branch_labels = ${repr(branch_labels)}
depends_on = ${repr(depends_on)}
def upgrade() -> None:
${upgrades if upgrades else "pass"}
def downgrade() -> None:
${downgrades if downgrades else "pass"}
+74
View File
@@ -0,0 +1,74 @@
"""init
Revision ID: 0001
Revises:
Create Date: 2026-11-06
"""
from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import postgresql
revision = "0001"
down_revision = None
branch_labels = None
depends_on = None
def upgrade() -> None:
op.create_table(
"users",
sa.Column("id", postgresql.UUID(as_uuid=True), primary_key=True),
sa.Column("username", sa.String(32), nullable=False, unique=True),
sa.Column("display_name", sa.String(100), nullable=False),
sa.Column("password_hash", sa.Text(), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
)
op.create_table(
"sessions",
sa.Column("token_hash", sa.String(64), primary_key=True),
sa.Column("user_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("users.id", ondelete="CASCADE"), nullable=False),
sa.Column("expires_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
)
op.create_index("ix_sessions_user_id", "sessions", ["user_id"])
op.create_index("ix_sessions_expires_at", "sessions", ["expires_at"])
op.create_table(
"chats",
sa.Column("id", postgresql.UUID(as_uuid=True), primary_key=True),
sa.Column("title", sa.String(100), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
)
op.create_table(
"chat_members",
sa.Column("chat_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True),
sa.Column("user_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("users.id", ondelete="CASCADE"), primary_key=True),
)
op.create_table(
"messages",
sa.Column("id", postgresql.UUID(as_uuid=True), primary_key=True),
sa.Column("chat_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("chats.id", ondelete="CASCADE"), nullable=False),
sa.Column("sender_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("users.id"), nullable=False),
sa.Column("text", sa.Text(), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
)
op.create_index("ix_messages_chat_created_id", "messages", ["chat_id", "created_at", "id"])
op.create_table(
"idempotency_keys",
sa.Column("user_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("users.id", ondelete="CASCADE"), primary_key=True),
sa.Column("method", sa.String(8), primary_key=True),
sa.Column("path", sa.String(255), primary_key=True),
sa.Column("key", sa.String(128), primary_key=True),
sa.Column("body_hash", sa.String(64), nullable=False),
sa.Column("message_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("messages.id", ondelete="CASCADE"), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
)
op.create_index("ix_idem_created", "idempotency_keys", ["created_at"])
def downgrade() -> None:
op.drop_table("idempotency_keys")
op.drop_table("messages")
op.drop_table("chat_members")
op.drop_table("chats")
op.drop_table("sessions")
op.drop_table("users")
+75
View File
@@ -0,0 +1,75 @@
import uuid
from datetime import datetime
from sqlalchemy import (
DateTime,
ForeignKey,
Index,
Integer,
String,
Text,
UniqueConstraint,
func,
)
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.orm import Mapped, mapped_column, relationship
from .db import Base
def _uuid() -> uuid.UUID:
return uuid.uuid4()
class User(Base):
__tablename__ = "users"
id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=_uuid)
username: Mapped[str] = mapped_column(String(32), unique=True, nullable=False)
display_name: Mapped[str] = mapped_column(String(100), nullable=False)
password_hash: Mapped[str] = mapped_column(Text, nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=False)
class SessionRow(Base):
__tablename__ = "sessions"
token_hash: Mapped[str] = mapped_column(String(64), primary_key=True)
user_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, index=True)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=False)
class Chat(Base):
__tablename__ = "chats"
id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=_uuid)
title: Mapped[str] = mapped_column(String(100), nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=False)
members: Mapped[list["ChatMember"]] = relationship(back_populates="chat", cascade="all, delete-orphan")
class ChatMember(Base):
__tablename__ = "chat_members"
chat_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True)
user_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), primary_key=True)
chat: Mapped[Chat] = relationship(back_populates="members")
class Message(Base):
__tablename__ = "messages"
id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=_uuid)
chat_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False)
sender_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False)
text: Mapped[str] = mapped_column(Text, nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=False)
__table_args__ = (Index("ix_messages_chat_created_id", "chat_id", "created_at", "id"),)
class IdempotencyKey(Base):
__tablename__ = "idempotency_keys"
user_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), primary_key=True)
method: Mapped[str] = mapped_column(String(8), primary_key=True)
path: Mapped[str] = mapped_column(String(255), primary_key=True)
key: Mapped[str] = mapped_column(String(128), primary_key=True)
body_hash: Mapped[str] = mapped_column(String(64), nullable=False)
message_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("messages.id", ondelete="CASCADE"), nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=False)
__table_args__ = (Index("ix_idem_created", "created_at"),)
View File
+54
View File
@@ -0,0 +1,54 @@
import base64
import binascii
from datetime import datetime, timezone
from fastapi import APIRouter, Depends, Request, Security
from fastapi.security import HTTPBasicCredentials
from sqlalchemy import delete, select
from sqlalchemy.orm import Session
from ..config import settings
from ..deps import basic_scheme, current_user, get_db
from ..errors import ApiError
from ..models import SessionRow, User
from ..schemas import SessionOut, UserOut
from ..security import new_token, session_expiry, token_hash, verify_password
router = APIRouter()
def _parse_basic(header: str):
if not header.lower().startswith("basic "):
raise ApiError(401, "unauthorized", "Требуется Basic")
try:
raw = base64.b64decode(header[6:].strip(), validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
raise ApiError(401, "unauthorized", "Некорректный Basic")
if ":" not in raw:
raise ApiError(401, "unauthorized", "Некорректный Basic")
username, password = raw.split(":", 1)
return username, password
@router.post("/api/v1/auth/sessions", response_model=SessionOut, status_code=201)
def login(
request: Request,
_basic: HTTPBasicCredentials | None = Security(basic_scheme),
db: Session = Depends(get_db),
):
username, password = _parse_basic(request.headers.get("authorization", ""))
user = db.scalar(select(User).where(User.username == username))
if user is None or not verify_password(password, user.password_hash):
raise ApiError(401, "unauthorized", "Неверные учётные данные")
token = new_token()
expires = session_expiry(settings.session_ttl_seconds)
db.add(SessionRow(token_hash=token_hash(token), user_id=user.id, expires_at=expires))
db.commit()
return SessionOut(token=token, token_type="Bearer", expires_at=expires, user=UserOut.model_validate(user, from_attributes=True))
@router.delete("/api/v1/auth/sessions/current", status_code=204)
def logout(request: Request, user: User = Security(current_user), db: Session = Depends(get_db)):
db.execute(delete(SessionRow).where(SessionRow.token_hash == request.state.token_hash))
db.commit()
return None
+100
View File
@@ -0,0 +1,100 @@
import base64
import json
import uuid
from datetime import datetime
from fastapi import APIRouter, Depends, Query, Security
from sqlalchemy import select
from sqlalchemy.orm import Session
from ..deps import current_user, get_db, parse_uuid
from ..errors import ApiError
from ..models import Chat, ChatMember, User
from ..schemas import ChatOut, ChatPage, CreateChat
router = APIRouter()
def _chat_out(chat: Chat, member_ids) -> ChatOut:
return ChatOut(id=chat.id, title=chat.title, member_ids=list(member_ids), created_at=chat.created_at)
def _member_ids(db: Session, chat_id) -> list:
return list(db.scalars(select(ChatMember.user_id).where(ChatMember.chat_id == chat_id)))
def _require_member(db: Session, chat_id, user_id) -> Chat:
chat = db.get(Chat, chat_id)
if chat is None:
raise ApiError(404, "not_found", "Чат не найден")
if db.get(ChatMember, (chat_id, user_id)) is None:
raise ApiError(404, "not_found", "Чат не найден")
return chat
def _encode_cursor(created_at: datetime, id_: uuid.UUID) -> str:
payload = json.dumps({"t": created_at.isoformat(), "i": str(id_)}).encode()
return base64.urlsafe_b64encode(payload).decode().rstrip("=")
def _decode_cursor(cursor: str):
try:
pad = "=" * (-len(cursor) % 4)
data = json.loads(base64.urlsafe_b64decode(cursor + pad))
return datetime.fromisoformat(data["t"]), uuid.UUID(data["i"])
except Exception:
raise ApiError(400, "invalid_request", "Некорректный cursor")
@router.post("/api/v1/chats", response_model=ChatOut, status_code=201)
def create_chat(body: CreateChat, user: User = Security(current_user), db: Session = Depends(get_db)):
if not body.title.strip():
raise ApiError(400, "invalid_request", "title не может быть пустым")
ids = list(dict.fromkeys(body.member_ids))
if user.id not in ids:
raise ApiError(400, "invalid_request", "Вызывающий должен быть участником")
found = set(db.scalars(select(User.id).where(User.id.in_(ids))))
if found != set(ids):
raise ApiError(400, "invalid_request", "Неизвестный участник")
chat = Chat(title=body.title)
db.add(chat)
db.flush()
for uid in ids:
db.add(ChatMember(chat_id=chat.id, user_id=uid))
db.commit()
db.refresh(chat)
return _chat_out(chat, ids)
@router.get("/api/v1/chats", response_model=ChatPage)
def list_chats(
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None),
user: User = Security(current_user),
db: Session = Depends(get_db),
):
stmt = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(ChatMember.user_id == user.id)
.order_by(Chat.created_at.asc(), Chat.id.asc())
.limit(limit + 1)
)
if cursor:
t, i = _decode_cursor(cursor)
stmt = stmt.where((Chat.created_at > t) | ((Chat.created_at == t) & (Chat.id > i)))
rows = list(db.scalars(stmt))
next_cursor = None
if len(rows) > limit:
rows = rows[:limit]
last = rows[-1]
next_cursor = _encode_cursor(last.created_at, last.id)
items = [_chat_out(c, _member_ids(db, c.id)) for c in rows]
return ChatPage(items=items, next_cursor=next_cursor)
@router.get("/api/v1/chats/{chat_id}", response_model=ChatOut)
def get_chat(chat_id: str, user: User = Security(current_user), db: Session = Depends(get_db)):
cid = parse_uuid(chat_id)
chat = _require_member(db, cid, user.id)
return _chat_out(chat, _member_ids(db, cid))
+23
View File
@@ -0,0 +1,23 @@
from fastapi import APIRouter, Depends
from sqlalchemy import text
from sqlalchemy.orm import Session
from ..deps import get_db
from ..errors import ApiError
from ..schemas import Health
router = APIRouter()
@router.get("/health/live", response_model=Health)
def live():
return Health()
@router.get("/health/ready", response_model=Health)
def ready(db: Session = Depends(get_db)):
try:
db.execute(text("SELECT 1"))
except Exception:
raise ApiError(503, "unavailable", "База данных недоступна")
return Health()
+98
View File
@@ -0,0 +1,98 @@
import hashlib
import json
import re
import uuid
from datetime import datetime, timedelta, timezone
from fastapi import APIRouter, Depends, Header, Query, Request, Security
from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from ..config import settings
from ..deps import current_user, get_db, parse_uuid
from ..errors import ApiError
from ..models import Chat, ChatMember, IdempotencyKey, Message, User
from ..schemas import CreateMessage, MessageOut, MessagePage
from .chats import _decode_cursor, _encode_cursor, _require_member
router = APIRouter()
_KEY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
def _body_hash(body: CreateMessage) -> str:
canonical = json.dumps({"text": body.text}, sort_keys=True, ensure_ascii=False)
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
@router.post("/api/v1/chats/{chat_id}/messages", response_model=MessageOut, status_code=201)
def create_message(
chat_id: str,
body: CreateMessage,
request: Request,
idempotency_key: str | None = Header(default=None, alias="Idempotency-Key"),
user: User = Security(current_user),
db: Session = Depends(get_db),
):
cid = parse_uuid(chat_id)
_require_member(db, cid, user.id)
if not body.text.strip():
raise ApiError(400, "invalid_request", "text не может быть пустым")
if not idempotency_key or not _KEY_RE.match(idempotency_key):
raise ApiError(400, "invalid_request", "Некорректный Idempotency-Key")
path = f"/api/v1/chats/{cid}/messages"
bh = _body_hash(body)
existing = db.get(IdempotencyKey, (user.id, "POST", path, idempotency_key))
if existing is not None:
if existing.body_hash != bh:
raise ApiError(409, "conflict", "Ключ уже использован с другим телом")
msg = db.get(Message, existing.message_id)
return MessageOut.model_validate(msg, from_attributes=True)
msg = Message(chat_id=cid, sender_id=user.id, text=body.text)
db.add(msg)
db.flush()
db.add(IdempotencyKey(user_id=user.id, method="POST", path=path, key=idempotency_key, body_hash=bh, message_id=msg.id))
try:
db.commit()
except IntegrityError:
db.rollback()
existing = db.get(IdempotencyKey, (user.id, "POST", path, idempotency_key))
if existing is None:
raise ApiError(500, "internal_error", "Не удалось сохранить сообщение")
if existing.body_hash != bh:
raise ApiError(409, "conflict", "Ключ уже использован с другим телом")
msg = db.get(Message, existing.message_id)
return MessageOut.model_validate(msg, from_attributes=True)
db.refresh(msg)
return MessageOut.model_validate(msg, from_attributes=True)
@router.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
def list_messages(
chat_id: str,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None),
user: User = Security(current_user),
db: Session = Depends(get_db),
):
cid = parse_uuid(chat_id)
_require_member(db, cid, user.id)
stmt = (
select(Message)
.where(Message.chat_id == cid)
.order_by(Message.created_at.asc(), Message.id.asc())
.limit(limit + 1)
)
if cursor:
t, i = _decode_cursor(cursor)
stmt = stmt.where((Message.created_at > t) | ((Message.created_at == t) & (Message.id > i)))
rows = list(db.scalars(stmt))
next_cursor = None
if len(rows) > limit:
rows = rows[:limit]
last = rows[-1]
next_cursor = _encode_cursor(last.created_at, last.id)
return MessagePage(items=[MessageOut.model_validate(m, from_attributes=True) for m in rows], next_cursor=next_cursor)
+32
View File
@@ -0,0 +1,32 @@
from fastapi import APIRouter, Depends, Security
from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from ..deps import current_user, get_db
from ..errors import ApiError
from ..models import User
from ..schemas import CreateUser, UserOut
from ..security import hash_password
router = APIRouter()
@router.post("/api/v1/users", response_model=UserOut, status_code=201)
def register(body: CreateUser, db: Session = Depends(get_db)):
if not body.display_name.strip():
raise ApiError(400, "invalid_request", "display_name не может быть пустым")
user = User(username=body.username, display_name=body.display_name, password_hash=hash_password(body.password))
db.add(user)
try:
db.commit()
except IntegrityError:
db.rollback()
raise ApiError(409, "conflict", "username занят")
db.refresh(user)
return user
@router.get("/api/v1/users/me", response_model=UserOut)
def me(user: User = Security(current_user)):
return user
+73
View File
@@ -0,0 +1,73 @@
import uuid
from datetime import datetime
from typing import List, Optional
from pydantic import BaseModel, ConfigDict, Field
class UserOut(BaseModel):
model_config = ConfigDict(extra="forbid")
id: uuid.UUID
username: str
display_name: str
created_at: datetime
class CreateUser(BaseModel):
model_config = ConfigDict(extra="forbid")
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
class SessionOut(BaseModel):
model_config = ConfigDict(extra="forbid")
token: str
token_type: str = "Bearer"
expires_at: datetime
user: UserOut
class ChatOut(BaseModel):
model_config = ConfigDict(extra="forbid")
id: uuid.UUID
title: str
member_ids: List[uuid.UUID]
created_at: datetime
class CreateChat(BaseModel):
model_config = ConfigDict(extra="forbid")
title: str = Field(min_length=1, max_length=100)
member_ids: List[uuid.UUID] = Field(min_length=1, max_length=100)
class MessageOut(BaseModel):
model_config = ConfigDict(extra="forbid")
id: uuid.UUID
chat_id: uuid.UUID
sender_id: uuid.UUID
text: str
created_at: datetime
class CreateMessage(BaseModel):
model_config = ConfigDict(extra="forbid")
text: str = Field(min_length=1, max_length=4000)
class ChatPage(BaseModel):
model_config = ConfigDict(extra="forbid")
items: List[ChatOut]
next_cursor: Optional[str]
class MessagePage(BaseModel):
model_config = ConfigDict(extra="forbid")
items: List[MessageOut]
next_cursor: Optional[str]
class Health(BaseModel):
model_config = ConfigDict(extra="forbid")
status: str = "ok"
+33
View File
@@ -0,0 +1,33 @@
import hashlib
import secrets
from datetime import datetime, timedelta, timezone
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
_ph = PasswordHasher()
def hash_password(password: str) -> str:
return _ph.hash(password)
def verify_password(password: str, hashed: str) -> bool:
try:
return _ph.verify(hashed, password)
except VerifyMismatchError:
return False
except Exception:
return False
def new_token() -> str:
return secrets.token_urlsafe(48)
def token_hash(token: str) -> str:
return hashlib.sha256(token.encode("utf-8")).hexdigest()
def session_expiry(ttl_seconds: int) -> datetime:
return datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds)
+129
View File
@@ -0,0 +1,129 @@
"""Сессии: PostgreSQL — источник истины, Redis — кэш с TTL.
При недоступности Redis работаем напрямую с БД (не принимаем анонимов).
При logout инвалидируем и БД, и кэш.
"""
import logging
import os
from datetime import datetime, timedelta, timezone
from typing import Any
import redis
from psycopg_pool import ConnectionPool
from .security import new_token, token_hash
logger = logging.getLogger("messenger.sessions")
def _now() -> datetime:
return datetime.now(timezone.utc)
def _ttl_seconds() -> int:
return int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
class SessionStore:
def __init__(self, pool: ConnectionPool, cache: redis.Redis | None) -> None:
self.pool = pool
self.cache = cache
# --- кэш --------------------------------------------------------------
def _cache_get(self, th: str) -> dict[str, Any] | None:
if self.cache is None:
return None
try:
raw = self.cache.hgetall("session:" + th)
except redis.RedisError as exc:
logger.warning("redis get failed: %s", type(exc).__name__)
return None
if not raw:
return None
return {
"user_id": raw[b"user_id"].decode(),
"expires_at": raw[b"expires_at"].decode(),
}
def _cache_put(self, th: str, user_id: str, expires_at: datetime) -> None:
if self.cache is None:
return
ttl = max(1, int((expires_at - _now()).total_seconds()))
try:
pipe = self.cache.pipeline()
pipe.hset(
"session:" + th,
mapping={
"user_id": user_id,
"expires_at": expires_at.strftime("%Y-%m-%dT%H:%M:%SZ"),
},
)
pipe.expire("session:" + th, ttl)
pipe.execute()
except redis.RedisError as exc:
logger.warning("redis put failed: %s", type(exc).__name__)
def _cache_del(self, th: str) -> None:
if self.cache is None:
return
try:
self.cache.delete("session:" + th)
except redis.RedisError as exc:
logger.warning("redis del failed: %s", type(exc).__name__)
# --- публичный API ----------------------------------------------------
def create(self, user_id: str) -> dict[str, Any]:
token = new_token()
th = token_hash(token)
expires_at = _now() + timedelta(seconds=_ttl_seconds())
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"INSERT INTO sessions(token_hash, user_id, created_at, expires_at)"
" VALUES (%s, %s, now(), %s)",
(th, user_id, expires_at),
)
conn.commit()
self._cache_put(th, user_id, expires_at)
return {
"token": token,
"expires_at": expires_at.strftime("%Y-%m-%dT%H:%M:%SZ"),
}
def resolve(self, token: str) -> str | None:
"""Возвращает user_id для действующей сессии или None."""
th = token_hash(token)
cached = self._cache_get(th)
if cached is not None:
try:
exp = datetime.strptime(cached["expires_at"], "%Y-%m-%dT%H:%M:%SZ").replace(
tzinfo=timezone.utc
)
except ValueError:
exp = None
if exp is not None and exp > _now():
return cached["user_id"]
self._cache_del(th)
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT user_id, expires_at FROM sessions WHERE token_hash = %s",
(th,),
)
row = cur.fetchone()
if row is None:
return None
user_id, expires_at = row
if expires_at <= _now():
self.revoke(token)
return None
self._cache_put(th, str(user_id), expires_at)
return str(user_id)
def revoke(self, token: str) -> None:
th = token_hash(token)
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute("DELETE FROM sessions WHERE token_hash = %s", (th,))
conn.commit()
self._cache_del(th)
+204
View File
@@ -0,0 +1,204 @@
"""Хранилище на PostgreSQL: пользователи, чаты, участники, сообщения."""
import uuid
from datetime import datetime, timezone
from typing import Any
import psycopg
from psycopg_pool import ConnectionPool
def utc_now() -> str:
"""RFC 3339 UTC с суффиксом Z, секунды — как в примерах контракта."""
return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
def new_id() -> str:
return str(uuid.uuid4())
def _iso(dt: datetime) -> str:
"""RFC 3339 UTC с суффиксом Z, микросекунды сохраняются для keyset-пагинации."""
return dt.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def _user_row(row: tuple) -> dict[str, Any]:
uid, username, display_name, created_at = row
return {
"id": str(uid),
"username": username,
"display_name": display_name,
"created_at": _iso(created_at),
}
def _chat_row(row: tuple, member_ids: list[str]) -> dict[str, Any]:
cid, title, created_at = row
return {
"id": str(cid),
"title": title,
"member_ids": member_ids,
"created_at": _iso(created_at),
}
def _message_row(row: tuple) -> dict[str, Any]:
mid, chat_id, sender_id, text, created_at = row
return {
"id": str(mid),
"chat_id": str(chat_id),
"sender_id": str(sender_id),
"text": text,
"created_at": _iso(created_at),
}
class Store:
"""Все данные в PostgreSQL; соединения берутся из пула."""
def __init__(self, pool: ConnectionPool) -> None:
self.pool = pool
# --- пользователи -----------------------------------------------------
def create_user(
self, username: str, display_name: str, password_hash: str
) -> dict[str, Any] | None:
user_id = new_id()
try:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"INSERT INTO users(id, username, display_name, password_hash, created_at)"
" VALUES (%s, %s, %s, %s, now())"
" RETURNING id, username, display_name, created_at",
(user_id, username, display_name, password_hash),
)
row = cur.fetchone()
conn.commit()
except psycopg.errors.UniqueViolation:
return None
return _user_row(row)
def get_user(self, user_id: str) -> dict[str, Any] | None:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
(user_id,),
)
row = cur.fetchone()
return _user_row(row) if row else None
def get_user_by_username(self, username: str) -> tuple[dict[str, Any], str] | None:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT id, username, display_name, created_at, password_hash"
" FROM users WHERE username = %s",
(username,),
)
row = cur.fetchone()
if row is None:
return None
return _user_row(row[:4]), row[4]
# --- чаты -------------------------------------------------------------
def create_chat(self, title: str, member_ids: list[str]) -> dict[str, Any]:
chat_id = new_id()
with self.pool.connection() as conn:
with conn.transaction():
with conn.cursor() as cur:
cur.execute(
"INSERT INTO chats(id, title, created_at) VALUES (%s, %s, now())"
" RETURNING id, title, created_at",
(chat_id, title),
)
row = cur.fetchone()
cur.executemany(
"INSERT INTO chat_members(chat_id, user_id) VALUES (%s, %s)",
[(chat_id, mid) for mid in member_ids],
)
return _chat_row(row, list(member_ids))
def _members(self, cur, chat_id: str) -> list[str]:
cur.execute(
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id",
(chat_id,),
)
return [str(r[0]) for r in cur.fetchall()]
def get_chat(self, chat_id: str) -> dict[str, Any] | None:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT id, title, created_at FROM chats WHERE id = %s", (chat_id,)
)
row = cur.fetchone()
if row is None:
return None
members = self._members(cur, chat_id)
return _chat_row(row, members)
def is_member(self, chat_id: str, user_id: str) -> bool:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id, user_id),
)
return cur.fetchone() is not None
def list_chats_for(
self, user_id: str, limit: int, after: tuple[str, str] | None
) -> tuple[list[dict[str, Any]], bool]:
with self.pool.connection() as conn:
with conn.cursor() as cur:
sql = (
"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"
)
params: list[Any] = [user_id]
if after is not None:
sql += " AND (c.created_at, c.id) > (%s, %s)"
params.extend(after)
sql += " ORDER BY c.created_at, c.id LIMIT %s"
params.append(limit + 1)
cur.execute(sql, params)
rows = cur.fetchall()
items = []
for row in rows[:limit]:
items.append(_chat_row(row, self._members(cur, str(row[0]))))
return items, len(rows) > limit
# --- сообщения --------------------------------------------------------
def add_message(self, chat_id: str, sender_id: str, text: str) -> dict[str, Any]:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"INSERT INTO messages(id, chat_id, sender_id, text, created_at)"
" VALUES (%s, %s, %s, %s, now())"
" RETURNING id, chat_id, sender_id, text, created_at",
(new_id(), chat_id, sender_id, text),
)
row = cur.fetchone()
conn.commit()
return _message_row(row)
def list_messages(
self, chat_id: str, limit: int, after: tuple[str, str] | None
) -> tuple[list[dict[str, Any]], bool]:
with self.pool.connection() as conn:
with conn.cursor() as cur:
sql = (
"SELECT id, chat_id, sender_id, text, created_at FROM messages"
" WHERE chat_id = %s"
)
params: list[Any] = [chat_id]
if after is not None:
sql += " AND (created_at, id) > (%s, %s)"
params.extend(after)
sql += " ORDER BY created_at, id LIMIT %s"
params.append(limit + 1)
cur.execute(sql, params)
rows = cur.fetchall()
return [_message_row(r) for r in rows[:limit]], len(rows) > limit
+122
View File
@@ -0,0 +1,122 @@
"""Валидация тел запросов и параметров вручную, без pydantic-моделей контракта."""
import base64
import re
import uuid
from typing import Any
from .errors import ApiError
USERNAME_RE = re.compile(r"\A[a-z0-9_]{3,32}\Z")
def _is_blank(value: str) -> bool:
return value.strip() == ""
def require_object(body: Any) -> dict[str, Any]:
if not isinstance(body, dict):
raise ApiError(400, "invalid_request", "Тело запроса должно быть JSON-объектом")
return body
def reject_extra(body: dict[str, Any], allowed: set[str]) -> None:
if set(body) - allowed:
raise ApiError(400, "invalid_request", "Неизвестные поля в теле запроса")
def validate_create_user(body: Any) -> tuple[str, str, str]:
body = require_object(body)
reject_extra(body, {"username", "display_name", "password"})
username = body.get("username")
display_name = body.get("display_name")
password = body.get("password")
if not isinstance(username, str) or not USERNAME_RE.match(username):
raise ApiError(400, "invalid_request", "Некорректный username")
if not isinstance(display_name, str) or not (1 <= len(display_name) <= 100) or _is_blank(display_name):
raise ApiError(400, "invalid_request", "Некорректный display_name")
if not isinstance(password, str) or not (12 <= len(password) <= 128):
raise ApiError(400, "invalid_request", "Пароль должен быть 12..128 символов")
return username, display_name, password
def validate_create_chat(body: Any, caller_id: str) -> tuple[str, list[str]]:
body = require_object(body)
reject_extra(body, {"title", "member_ids"})
title = body.get("title")
member_ids = body.get("member_ids")
if not isinstance(title, str) or not (1 <= len(title) <= 100) or _is_blank(title):
raise ApiError(400, "invalid_request", "Некорректный title")
if not isinstance(member_ids, list) or not (1 <= len(member_ids) <= 100):
raise ApiError(400, "invalid_request", "member_ids должен быть непустым массивом")
seen: set[str] = set()
for mid in member_ids:
if not isinstance(mid, str):
raise ApiError(400, "invalid_request", "member_ids содержит не строку")
try:
uuid.UUID(mid)
except ValueError:
raise ApiError(400, "invalid_request", "member_ids содержит не UUID")
if mid in seen:
raise ApiError(400, "invalid_request", "member_ids содержит дубликаты")
seen.add(mid)
if caller_id not in seen:
raise ApiError(400, "invalid_request", "Вызывающий должен входить в member_ids")
return title, list(member_ids)
def validate_create_message(body: Any) -> str:
body = require_object(body)
reject_extra(body, {"text"})
text = body.get("text")
if not isinstance(text, str) or not (1 <= len(text) <= 4000) or _is_blank(text):
raise ApiError(400, "invalid_request", "Некорректный text")
return text
def validate_chat_id(raw: str) -> str:
"""chat_id в пути должен быть UUID, иначе 400 invalid_request."""
try:
uuid.UUID(raw)
except (ValueError, TypeError):
raise ApiError(400, "invalid_request", "Некорректный chat_id")
return raw
def parse_limit(raw: str | None, default: int = 50) -> int:
if raw is None:
return default
try:
value = int(raw)
except (TypeError, ValueError):
raise ApiError(400, "invalid_request", "limit должен быть целым числом")
if not (1 <= value <= 100):
raise ApiError(400, "invalid_request", "limit вне диапазона 1..100")
return value
def parse_cursor(raw: str | None, scope: str) -> tuple[str, str] | None:
"""Cursor — непрозрачная строка base64url от 'scope|created_at|id'.
Cursor привязан к ресурсу (scope). Значения created_at/id — из БД,
поэтому cursor переживает рестарт процесса.
"""
if raw is None:
return None
try:
decoded = base64.urlsafe_b64decode(raw.encode("ascii")).decode("utf-8")
except Exception:
raise ApiError(400, "invalid_request", "Некорректный cursor")
parts = decoded.split("|")
if len(parts) != 3:
raise ApiError(400, "invalid_request", "Некорректный cursor")
cursor_scope, created_at, item_id = parts
if cursor_scope != scope:
raise ApiError(400, "invalid_request", "Некорректный cursor")
if not created_at or not item_id:
raise ApiError(400, "invalid_request", "Некорректный cursor")
return created_at, item_id
def encode_cursor(created_at: str, item_id: str, scope: str) -> str:
raw = "|".join([scope, created_at, item_id]).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii")
+114
View File
@@ -0,0 +1,114 @@
name: messenger-lab3
x-api-common: &api-common
build:
context: .
dockerfile: Dockerfile
image: messenger-lab3-api:local
restart: unless-stopped
environment:
DATABASE_URL: postgresql+psycopg://messenger:${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD}@postgres:5432/messenger
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
APP_HOST: 0.0.0.0
APP_PORT: "8080"
depends_on:
postgres:
condition: service_healthy
migrate:
condition: service_completed_successfully
networks: [backend]
deploy:
resources:
limits:
cpus: "0.50"
memory: 256M
healthcheck:
test: ["CMD", "curl", "-fsS", "http://127.0.0.1:8080/health/ready"]
interval: 5s
timeout: 2s
retries: 3
start_period: 10s
stop_grace_period: 15s
services:
postgres:
image: postgres:16.4-alpine
restart: unless-stopped
environment:
POSTGRES_USER: messenger
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD}
POSTGRES_DB: messenger
volumes:
- pgdata:/var/lib/postgresql/data
networks: [backend]
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
deploy:
resources:
limits:
cpus: "1.00"
memory: 512M
migrate:
build:
context: .
dockerfile: Dockerfile
image: messenger-lab3-api:local
restart: "no"
command: ["alembic", "upgrade", "head"]
environment:
DATABASE_URL: postgresql+psycopg://messenger:${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD}@postgres:5432/messenger
depends_on:
postgres:
condition: service_healthy
networks: [backend]
api-1:
<<: *api-common
environment:
DATABASE_URL: postgresql+psycopg://messenger:${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD}@postgres:5432/messenger
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
APP_HOST: 0.0.0.0
APP_PORT: "8080"
INSTANCE_ID: api-1
api-2:
<<: *api-common
environment:
DATABASE_URL: postgresql+psycopg://messenger:${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD}@postgres:5432/messenger
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
APP_HOST: 0.0.0.0
APP_PORT: "8080"
INSTANCE_ID: api-2
lb:
image: nginx:1.27.3-alpine
restart: unless-stopped
ports:
- "8080:8080"
volumes:
- ./infra/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
depends_on:
api-1:
condition: service_healthy
api-2:
condition: service_healthy
networks: [backend]
deploy:
resources:
limits:
cpus: "0.50"
memory: 128M
volumes:
pgdata:
networks:
backend:
driver: bridge
+194
View File
@@ -0,0 +1,194 @@
# compose-config — 2026-11-06T11:00:55Z
name: messenger-lab3
services:
api-1:
build:
context: C:\All\projects\highload\mtusi2026lab3
dockerfile: Dockerfile
depends_on:
migrate:
condition: service_completed_successfully
required: true
postgres:
condition: service_healthy
required: true
deploy:
resources:
limits:
cpus: 0.5
memory: "268435456"
environment:
APP_HOST: 0.0.0.0
APP_PORT: "8080"
DATABASE_URL: postgresql+psycopg://messenger:secretpassword@postgres:5432/messenger
IDEMPOTENCY_TTL_SECONDS: "86400"
INSTANCE_ID: api-1
SESSION_TTL_SECONDS: "3600"
healthcheck:
test:
- CMD
- curl
- -fsS
- http://127.0.0.1:8080/health/ready
timeout: 2s
interval: 5s
retries: 3
start_period: 10s
image: messenger-lab3-api:local
networks:
backend: null
restart: unless-stopped
stop_grace_period: 15s
api-2:
build:
context: C:\All\projects\highload\mtusi2026lab3
dockerfile: Dockerfile
depends_on:
migrate:
condition: service_completed_successfully
required: true
postgres:
condition: service_healthy
required: true
deploy:
resources:
limits:
cpus: 0.5
memory: "268435456"
environment:
APP_HOST: 0.0.0.0
APP_PORT: "8080"
DATABASE_URL: postgresql+psycopg://messenger:secretpassword@postgres:5432/messenger
IDEMPOTENCY_TTL_SECONDS: "86400"
INSTANCE_ID: api-2
SESSION_TTL_SECONDS: "3600"
healthcheck:
test:
- CMD
- curl
- -fsS
- http://127.0.0.1:8080/health/ready
timeout: 2s
interval: 5s
retries: 3
start_period: 10s
image: messenger-lab3-api:local
networks:
backend: null
restart: unless-stopped
stop_grace_period: 15s
lb:
depends_on:
api-1:
condition: service_healthy
required: true
api-2:
condition: service_healthy
required: true
deploy:
resources:
limits:
cpus: 0.5
memory: "134217728"
image: nginx:1.27.3-alpine
networks:
backend: null
ports:
- mode: ingress
target: 8080
published: "8080"
protocol: tcp
restart: unless-stopped
volumes:
- type: bind
source: C:\All\projects\highload\mtusi2026lab3\infra\nginx\nginx.conf
target: /etc/nginx/nginx.conf
read_only: true
bind:
create_host_path: true
migrate:
build:
context: C:\All\projects\highload\mtusi2026lab3
dockerfile: Dockerfile
command:
- alembic
- upgrade
- head
depends_on:
postgres:
condition: service_healthy
required: true
environment:
DATABASE_URL: postgresql+psycopg://messenger:secretpassword@postgres:5432/messenger
image: messenger-lab3-api:local
networks:
backend: null
restart: "no"
postgres:
deploy:
resources:
limits:
cpus: 1
memory: "536870912"
environment:
POSTGRES_DB: messenger
POSTGRES_PASSWORD: secretpassword
POSTGRES_USER: messenger
healthcheck:
test:
- CMD-SHELL
- pg_isready -U messenger -d messenger
timeout: 3s
interval: 5s
retries: 10
image: postgres:16.4-alpine
networks:
backend: null
restart: unless-stopped
volumes:
- type: volume
source: pgdata
target: /var/lib/postgresql/data
volume: {}
networks:
backend:
name: messenger-lab3_backend
driver: bridge
volumes:
pgdata:
name: messenger-lab3_pgdata
x-api-common:
build:
context: .
dockerfile: Dockerfile
depends_on:
migrate:
condition: service_completed_successfully
postgres:
condition: service_healthy
deploy:
resources:
limits:
cpus: "0.50"
memory: 256M
environment:
APP_HOST: 0.0.0.0
APP_PORT: "8080"
DATABASE_URL: postgresql+psycopg://messenger:secretpassword@postgres:5432/messenger
IDEMPOTENCY_TTL_SECONDS: "86400"
SESSION_TTL_SECONDS: "3600"
healthcheck:
interval: 5s
retries: 3
start_period: 10s
test:
- CMD
- curl
- -fsS
- http://127.0.0.1:8080/health/ready
timeout: 2s
image: messenger-lab3-api:local
networks:
- backend
restart: unless-stopped
stop_grace_period: 15s
+4
View File
@@ -0,0 +1,4 @@
# dependency.txt — 2026-11-06T11:00:51Z
# cmd: python3 tests/test_dependency_failure.py --base-url http://localhost:8080
scripts/collect-evidence.sh: line 22: python3: command not found
# status: OK
+9
View File
@@ -0,0 +1,9 @@
# failover.txt — 2026-11-06T11:00:32Z
# cmd: make test-failover ACTION_SCRIPT=scripts/stop-one.sh
make[1]: Entering directory 'C:/All/projects/highload/mtusi2026lab3'
python tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 37, "failed_attempts": 1, "first_recovery_seconds": 2.875}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
make[1]: Leaving directory 'C:/All/projects/highload/mtusi2026lab3'
# status: OK
+21
View File
@@ -0,0 +1,21 @@
# health — 2026-11-06T11:00:54Z
## /health/live
HTTP/1.1 200 OK
Server: nginx/1.27.3
Date: Fri, 06 Nov 2026 11:00:55 GMT
Content-Type: application/json
Content-Length: 15
Connection: keep-alive
x-request-id: 0a44ba35ed6c4a2bacec872c56bf6e71
x-instance-id: api-2
## /health/ready
HTTP/1.1 200 OK
Server: nginx/1.27.3
Date: Fri, 06 Nov 2026 11:00:55 GMT
Content-Type: application/json
Content-Length: 15
Connection: keep-alive
x-request-id: 382144b096174b77b798b94f2d81eab7
x-instance-id: api-2
+8
View File
@@ -0,0 +1,8 @@
# instances — 2026-11-06T11:00:52Z
# cmd: 6x curl -sI http://localhost:8080/health/live
x-instance-id: api-2
x-instance-id: api-2
x-instance-id: api-2
x-instance-id: api-2
x-instance-id: api-2
x-instance-id: api-2
+2
View File
@@ -0,0 +1,2 @@
# load — 2026-11-06T11:00:56Z
scripts/collect-evidence.sh: line 71: python3: command not found
+5
View File
@@ -0,0 +1,5 @@
# migrate — 2026-11-06T11:00:55Z
migrate-1 | INFO [alembic.runtime.migration] Context impl PostgresqlImpl.
migrate-1 | INFO [alembic.runtime.migration] Will assume transactional DDL.
migrate-1 | INFO [alembic.runtime.migration] Context impl PostgresqlImpl.
migrate-1 | INFO [alembic.runtime.migration] Will assume transactional DDL.
+8
View File
@@ -0,0 +1,8 @@
# persistence.txt — 2026-11-06T11:00:21Z
# cmd: make test-persistence ACTION_SCRIPT=scripts/restart.sh
make[1]: Entering directory 'C:/All/projects/highload/mtusi2026lab3'
python tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
make[1]: Leaving directory 'C:/All/projects/highload/mtusi2026lab3'
# status: OK
+7
View File
@@ -0,0 +1,7 @@
# smoke.txt — 2026-11-06T11:00:09Z
# cmd: make test BASE_URL=http://localhost:8080
make[1]: Entering directory 'C:/All/projects/highload/mtusi2026lab3'
python tests/smoke.py --base-url http://localhost:8080
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
make[1]: Leaving directory 'C:/All/projects/highload/mtusi2026lab3'
# status: OK
+33
View File
@@ -0,0 +1,33 @@
worker_processes auto;
events { worker_connections 1024; }
http {
log_format main '$remote_addr "$request" $status $upstream_addr $request_time';
access_log /var/log/nginx/access.log main;
error_log /var/log/nginx/error.log warn;
upstream api_backend {
server api-1:8080 max_fails=2 fail_timeout=5s;
server api-2:8080 max_fails=2 fail_timeout=5s;
keepalive 32;
}
server {
listen 8080;
client_max_body_size 16m;
location / {
proxy_pass http://api_backend;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 2s;
proxy_send_timeout 30s;
proxy_read_timeout 30s;
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 2;
}
}
}
+32
View File
@@ -0,0 +1,32 @@
CREATE TABLE users (
id UUID PRIMARY KEY,
username TEXT NOT NULL UNIQUE,
display_name TEXT NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members(user_id);
CREATE TABLE 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-пагинацию истории чата: (chat_id, created_at, id).
CREATE INDEX messages_chat_created_idx ON messages(chat_id, created_at, id);
+9
View File
@@ -0,0 +1,9 @@
CREATE TABLE sessions (
token_hash TEXT PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
created_at TIMESTAMPTZ NOT NULL,
expires_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX sessions_user_idx ON sessions(user_id);
CREATE INDEX sessions_expires_idx ON sessions(expires_at);
+9
View File
@@ -0,0 +1,9 @@
fastapi==0.115.5
uvicorn[standard]==0.32.1
SQLAlchemy==2.0.36
psycopg[binary]==3.2.3
psycopg-pool==3.2.3
redis==5.2.0
alembic==1.14.0
argon2-cffi==23.1.0
pydantic==2.10.3
+4 -4
View File
@@ -8,8 +8,8 @@ import re
ROOT = Path(__file__).resolve().parents[1]
def main():
lab = json.loads((ROOT/'lab.json').read_text())['number']
spec = json.loads((ROOT/'contracts/openapi.json').read_text())
lab = json.loads((ROOT/'lab.json').read_text(encoding='utf-8'))['number']
spec = json.loads((ROOT/'contracts/openapi.json').read_text(encoding='utf-8'))
assert spec['openapi']=='3.1.0'
assert spec['info']['version']=='1.%d.0'%lab
operation_ids = set()
@@ -41,11 +41,11 @@ def main():
assert ('/api/v1/auth/sessions' in spec['paths']) == (lab>=2)
assert ('/api/v1/attachments/{attachment_id}' in spec['paths']) == (lab>=4)
for file in list((ROOT/'tests').glob('*.py'))+list((ROOT/'scripts').glob('*.py')):
ast.parse(file.read_text(),filename=str(file))
ast.parse(file.read_text(encoding='utf-8'),filename=str(file))
for file in ROOT.rglob('*.json'):
if any(part in {'.git','.venv','node_modules','vendor','output'} for part in file.parts):
continue
json.loads(file.read_text())
json.loads(file.read_text(encoding='utf-8'))
for required in ('README.md','COURSE.md','CONTRIBUTING.md','REPORT.md','contracts/README.md','tests/smoke.py','tests/README.md'):
assert (ROOT/required).is_file(), 'missing '+required
print('PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.')
+74
View File
@@ -0,0 +1,74 @@
#!/bin/sh
# Collect evidence for lab3 report. Redacts secrets before writing.
# Usage: sh scripts/collect-evidence.sh
set -u
cd "$(dirname "$0")/.."
mkdir -p evidence
redact() {
# Strip Authorization headers, tokens, passwords from stdin.
sed -E \
-e 's/(Authorization:[[:space:]]*)[^[:space:]]+/\1<redacted>/Ig' \
-e 's/("token"[[:space:]]*:[[:space:]]*")[^"]+/\1<redacted>/g' \
-e 's/("password"[[:space:]]*:[[:space:]]*")[^"]+/\1<redacted>/g' \
-e 's/(POSTGRES_PASSWORD=)[^[:space:]]+/\1<redacted>/g'
}
run_step() {
name="$1"; shift
out="evidence/$name"
echo "# $name — $(date -u +%Y-%m-%dT%H:%M:%SZ)" > "$out"
echo "# cmd: $*" >> "$out"
if "$@" 2>&1 | redact >> "$out"; then
echo "# status: OK" >> "$out"
else
echo "# status: FAILED" >> "$out"
fi
}
BASE_URL="${BASE_URL:-http://localhost:8080}"
run_step smoke.txt make test BASE_URL="$BASE_URL"
run_step persistence.txt make test-persistence ACTION_SCRIPT=scripts/restart.sh
run_step failover.txt make test-failover ACTION_SCRIPT=scripts/stop-one.sh
run_step dependency.txt python3 tests/test_dependency_failure.py --base-url "$BASE_URL"
# Instances: 6 requests, extract X-Instance-Id.
{
echo "# instances — $(date -u +%Y-%m-%dT%H:%M:%SZ)"
echo "# cmd: 6x curl -sI $BASE_URL/health/live"
i=0
while [ $i -lt 6 ]; do
curl -sI "$BASE_URL/health/live" | grep -i '^x-instance-id:' || echo "x-instance-id: <missing>"
i=$((i+1))
done
} > evidence/instances.txt
# Health with headers.
{
echo "# health — $(date -u +%Y-%m-%dT%H:%M:%SZ)"
echo "## /health/live"
curl -s -D - -o /dev/null "$BASE_URL/health/live" | redact
echo "## /health/ready"
curl -s -D - -o /dev/null "$BASE_URL/health/ready" | redact
} > evidence/health.txt
# Compose config (redacted).
{
echo "# compose-config — $(date -u +%Y-%m-%dT%H:%M:%SZ)"
docker compose --env-file .env config 2>&1 | redact
} > evidence/compose-config.txt
# Migrate logs.
{
echo "# migrate — $(date -u +%Y-%m-%dT%H:%M:%SZ)"
docker compose --env-file .env logs migrate 2>&1 | redact
} > evidence/migrate.txt
# Load test.
{
echo "# load — $(date -u +%Y-%m-%dT%H:%M:%SZ)"
python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load.json 2>&1 | redact
} > evidence/load.txt
echo "Evidence collected in evidence/"
+8
View File
@@ -0,0 +1,8 @@
-- Ожидаем Index Scan по messages_chat_created_idx, без Seq Scan всей истории.
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '00000000-0000-4000-8000-000000000000'
AND (created_at, id) > ('2026-01-01T00:00:00Z', '00000000-0000-4000-8000-000000000000')
ORDER BY created_at, id
LIMIT 51;
+18
View File
@@ -0,0 +1,18 @@
#!/bin/sh
set -eu
# Restart API replicas and PostgreSQL preserving volumes and data.
# Does NOT remove volumes, does NOT re-seed, does NOT print credentials.
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres
docker compose --env-file .env restart api-1 api-2
# Wait for readiness through the LB.
i=0
while [ $i -lt 60 ]; do
if curl -fsS http://localhost:8080/health/ready >/dev/null 2>&1; then
exit 0
fi
i=$((i+1))
sleep 1
done
echo "readiness timeout" >&2
exit 1
+100
View File
@@ -0,0 +1,100 @@
#!/usr/bin/env python3
"""Создаёт >=10 000 сообщений и снимает EXPLAIN (ANALYZE, BUFFERS).
Запуск: python3 scripts/seed_history.py --count 10000 --output evidence/explain.txt
Требует запущенный API (BASE_URL) и доступ к psql через docker compose exec.
"""
import argparse
import base64
import json
import os
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
def request(base, method, path, body=None, token=None, basic=None):
headers = {"Accept": "application/json"}
if token:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + basic
data = None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
headers["Content-Type"] = "application/json"
req = urllib.request.Request(base + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(req, timeout=30) as resp:
payload = resp.read()
return resp.status, json.loads(payload) if payload else None
except urllib.error.HTTPError as err:
payload = err.read()
return err.code, json.loads(payload) if payload else None
def main():
p = argparse.ArgumentParser(description="Seed history and run EXPLAIN")
p.add_argument("--base-url", default=os.environ.get("BASE_URL", "http://localhost:8080"))
p.add_argument("--count", type=int, default=10000)
p.add_argument("--output", default="evidence/explain.txt")
p.add_argument("--psql", default="docker compose exec -T postgres psql -U messenger -d messenger")
args = p.parse_args()
base = args.base_url.rstrip("/")
username = "u_seed_" + uuid.uuid4().hex[:10]
password = "T3st-" + uuid.uuid4().hex
status, alice = request(base, "POST", "/api/v1/users",
{"username": username, "display_name": "Seed", "password": password})
assert status == 201, (status, alice)
basic = base64.b64encode((username + ":" + password).encode()).decode()
status, session = request(base, "POST", "/api/v1/auth/sessions", basic=basic)
assert status == 201, (status, session)
token = session["token"]
status, chat = request(base, "POST", "/api/v1/chats",
{"title": "Seed history", "member_ids": [alice["id"]]}, token=token)
assert status == 201, (status, chat)
chat_id = chat["id"]
started = time.monotonic()
for i in range(args.count):
status, _ = request(base, "POST", "/api/v1/chats/" + chat_id + "/messages",
{"text": "seed-%d" % i}, token=token)
if status != 201:
raise SystemExit("failed to insert message %d: %s" % (i, status))
if (i + 1) % 1000 == 0:
print("inserted %d/%d" % (i + 1, args.count), file=sys.stderr)
elapsed = time.monotonic() - started
print("inserted %d messages in %.1fs" % (args.count, elapsed), file=sys.stderr)
sql = (
"EXPLAIN (ANALYZE, BUFFERS) "
"SELECT id, chat_id, sender_id, text, created_at FROM messages "
"WHERE chat_id = '%s' "
"AND (created_at, id) > ('1970-01-01T00:00:00Z', '00000000-0000-0000-0000-000000000000') "
"ORDER BY created_at, id LIMIT 51;" % chat_id
)
proc = subprocess.run(args.psql.split() + ["-c", sql], cwd=str(ROOT),
capture_output=True, text=True, timeout=120)
if proc.returncode != 0:
raise SystemExit("psql failed: " + proc.stderr[:500])
out = proc.stdout
dest = (ROOT / args.output).resolve()
dest.parent.mkdir(parents=True, exist_ok=True)
dest.write_text(
"# chat_id=%s count=%d\n%s\n" % (chat_id, args.count, out),
encoding="utf-8",
)
print(out)
print("saved to " + str(dest), file=sys.stderr)
if __name__ == "__main__":
main()
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
set -eu
# Поднимает PostgreSQL обратно и ждёт готовности.
docker compose start postgres
i=0
while [ "$i" -lt 60 ]; do
if docker compose exec -T postgres pg_isready -U messenger -d messenger >/dev/null 2>&1; then
exit 0
fi
i=$((i+1))
sleep 1
done
echo "postgres did not become ready" >&2
exit 1
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
set -eu
# Поднимает Redis обратно и ждёт готовности.
docker compose start redis
i=0
while [ "$i" -lt 30 ]; do
if docker compose exec -T redis redis-cli ping >/dev/null 2>&1; then
exit 0
fi
i=$((i+1))
sleep 1
done
echo "redis did not become ready" >&2
exit 1
+12
View File
@@ -0,0 +1,12 @@
#!/bin/sh
set -eu
# Stop exactly one API replica identified by TARGET_INSTANCE_ID (api-1 or api-2).
# Leaves it stopped; does not touch DB/LB/volumes.
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
cd "$(dirname "$0")/.."
case "$TARGET_INSTANCE_ID" in
api-1|api-2) ;;
*) echo "unknown TARGET_INSTANCE_ID: $TARGET_INSTANCE_ID" >&2; exit 2 ;;
esac
docker compose --env-file .env stop "$TARGET_INSTANCE_ID"
exit 0
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
# Останавливает PostgreSQL, сохраняя volume. Используется тестом недоступности.
docker compose stop postgres
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
# Останавливает Redis, сохраняя volume. Используется тестом недоступности.
docker compose stop redis
+3 -3
View File
@@ -6,17 +6,17 @@ from openapi_spec_validator import validate
from jsonschema import Draft202012Validator
root = Path(__file__).resolve().parents[1]
spec = json.loads((root/'contracts/openapi.json').read_text())
spec = json.loads((root/'contracts/openapi.json').read_text(encoding='utf-8'))
validate(spec)
from referencing import Registry, Resource
# The base URI resolves local #/components references inside examples.
resource = dict(spec, **{'$schema': 'https://json-schema.org/draft/2020-12/schema'})
registry = Registry().with_resource('urn:mtusi:openapi', Resource.from_contents(resource))
for name, example in json.loads((root/'contracts/examples.json').read_text()).items():
for name, example in json.loads((root/'contracts/examples.json').read_text(encoding='utf-8')).items():
schema = {'$ref': 'urn:mtusi:openapi#/components/schemas/' + name}
Draft202012Validator(schema, registry=registry).validate(example)
for path in (root/'contracts').glob('*.schema.json'):
schema = json.loads(path.read_text())
schema = json.loads(path.read_text(encoding='utf-8'))
Draft202012Validator.check_schema(schema)
for example in schema.get('examples',[]):
Draft202012Validator(schema).validate(example)
+2 -2
View File
@@ -13,8 +13,8 @@ import urllib.request
import uuid
ROOT = Path(__file__).resolve().parents[1]
LAB = json.loads((ROOT / 'lab.json').read_text())['number']
SPEC = json.loads((ROOT / 'contracts/openapi.json').read_text())
LAB = json.loads((ROOT / 'lab.json').read_text(encoding='utf-8'))['number']
SPEC = json.loads((ROOT / 'contracts/openapi.json').read_text(encoding='utf-8'))
class Failure(AssertionError):
pass
+22 -2
View File
@@ -2,6 +2,7 @@
"""Explicit operator-authored hook; tokens remain in memory, volumes are never removed by this test."""
import json
import os
import shutil
from pathlib import Path
import subprocess
import time
@@ -10,6 +11,25 @@ from urllib.parse import quote
from client import Client, Failure, LAB, arguments, check, run
def _script_command(full: Path) -> list[str]:
"""Windows не умеет запускать .sh напрямую — вызываем через sh (Git Bash/WSL)."""
if os.name == "nt":
sh = shutil.which("sh") or shutil.which("bash")
if not sh:
raise Failure(
"sh/bash not found in PATH; install Git for Windows or run under WSL"
)
return [sh, str(full)]
return [str(full)]
def _is_executable(full: Path) -> bool:
"""На Windows .sh не имеет executable bit — проверяем через sh."""
if os.name == "nt":
return full.is_file() and (shutil.which("sh") or shutil.which("bash")) is not None
return full.is_file() and os.access(full, os.X_OK)
def history(c, actor, chat):
path = '/api/v1/chats/'+chat['id']+'/messages?limit=100'
result = []
@@ -34,7 +54,7 @@ def main():
check(LAB>=2,'persistence requires lab2+')
check(args.mode!='failover' or LAB>=3,'failover requires lab3+')
script = Path(args.action_script).expanduser().resolve()
check(script.is_file() and os.access(script,os.X_OK),'action script must exist and be executable (chmod +x)')
check(_is_executable(script),'action script must exist and be executable (chmod +x)')
check('.example.' not in script.name,'copy and implement the example hook first')
c = Client(args.base_url,args.ca_file,timeout=2)
alice,bob,eve,chat = c.bootstrap()
@@ -55,7 +75,7 @@ def main():
check(len(observed)>=2,'less than two API instances observed before failure; verify LB/session affinity')
print('Executing explicit '+args.mode+' hook; hook output suppressed to avoid leaking secrets.')
# No shell interpolation and no Docker commands in this test.
proc = subprocess.Popen([str(script)],env=env,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
proc = subprocess.Popen(_script_command(script),env=env,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
started = time.monotonic()
successes,failures,after_instances = [],0,[]
try:
+147
View File
@@ -0,0 +1,147 @@
#!/usr/bin/env python3
"""Проверка недоступности Redis и PostgreSQL.
Управление контейнерами — через скрипты scripts/stop-*.sh / start-*.sh,
чтобы тест не зависел от Docker напрямую.
"""
import argparse
import base64
import json
import os
import shutil
import subprocess
import sys
import time
import unittest
import urllib.error
import urllib.request
import uuid
from pathlib import Path
_parser = argparse.ArgumentParser(description="Dependency failure tests")
_parser.add_argument("--base-url", default=None)
_parser.add_argument("--stop-redis", default="scripts/stop-redis.sh")
_parser.add_argument("--start-redis", default="scripts/start-redis.sh")
_parser.add_argument("--stop-postgres", default="scripts/stop-postgres.sh")
_parser.add_argument("--start-postgres", default="scripts/start-postgres.sh")
_args, _unknown = _parser.parse_known_args()
sys.argv = [sys.argv[0]] + _unknown
BASE_URL = (_args.base_url or os.environ.get("BASE_URL") or "http://localhost:8080").rstrip("/")
ROOT = Path(__file__).resolve().parents[1]
def _script_command(full: Path) -> list[str]:
"""Windows не умеет запускать .sh напрямую — вызываем через sh (Git Bash/WSL)."""
if os.name == "nt":
sh = shutil.which("sh") or shutil.which("bash")
if not sh:
raise unittest.SkipTest(
"sh/bash not found in PATH; install Git for Windows or run under WSL"
)
return [sh, str(full)]
return [str(full)]
def run_script(path):
full = (ROOT / path).resolve()
if not full.is_file():
raise unittest.SkipTest("script not found: " + str(full))
cmd = _script_command(full)
proc = subprocess.run(cmd, cwd=str(ROOT), capture_output=True, timeout=120)
if proc.returncode != 0:
raise AssertionError(
"script failed: " + path + " rc=" + str(proc.returncode)
+ " stderr=" + proc.stderr.decode("utf-8", "replace")[:500]
)
def request(method, path, body=None, token=None, basic=None):
headers = {"Accept": "application/json"}
if token:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + basic
data = None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
headers["Content-Type"] = "application/json"
req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
payload = resp.read()
return resp.status, json.loads(payload) if payload else None
except urllib.error.HTTPError as err:
payload = err.read()
return err.code, json.loads(payload) if payload else None
def make_user(label):
username = "u_" + label + "_" + uuid.uuid4().hex[:10]
password = "T3st-" + uuid.uuid4().hex
status, user = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Dep " + label, "password": password},
)
assert status == 201, (status, user)
basic = base64.b64encode((username + ":" + password).encode()).decode()
status, session = request("POST", "/api/v1/auth/sessions", basic=basic)
assert status == 201, (status, session)
return {"user": user, "token": session["token"]}
def wait_ready(timeout=60):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
status, _ = request("GET", "/health/ready")
if status == 200:
return
except Exception:
pass
time.sleep(0.5)
raise AssertionError("API did not become ready within " + str(timeout) + "s")
class DependencyFailureTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.alice = make_user("alice")
def test_redis_down_falls_back_to_db(self):
run_script(_args.stop_redis)
try:
# Валидный токен продолжает работать (fallback на БД).
status, body = request("GET", "/api/v1/users/me", token=self.alice["token"])
self.assertEqual(status, 200, body)
self.assertEqual(body["id"], self.alice["user"]["id"])
# Аноним не принимается.
status, body = request("GET", "/api/v1/users/me")
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
# /health/ready не зависит от Redis.
status, _ = request("GET", "/health/ready")
self.assertEqual(status, 200)
finally:
run_script(_args.start_redis)
wait_ready()
def test_postgres_down_returns_503(self):
run_script(_args.stop_postgres)
try:
status, body = request("GET", "/health/ready")
self.assertEqual(status, 503)
self.assertEqual(body["error"]["code"], "unavailable")
# Бизнес-запрос не должен отдавать 200 и не должен раскрывать детали.
status, body = request("GET", "/api/v1/users/me", token=self.alice["token"])
self.assertIn(status, (500, 503))
self.assertIn("error", body)
self.assertNotIn("psycopg", json.dumps(body).lower())
finally:
run_script(_args.start_postgres)
wait_ready()
if __name__ == "__main__":
unittest.main(verbosity=2)
+93
View File
@@ -0,0 +1,93 @@
#!/usr/bin/env python3
"""Проверка expiry сессии при коротком SESSION_TTL_SECONDS.
Запускается против стенда с SESSION_TTL_SECONDS <= 10 (например, 2).
Если TTL больше — тест скипается, чтобы не ждать минуты.
"""
import argparse
import base64
import json
import os
import sys
import time
import unittest
import urllib.error
import urllib.request
import uuid
_parser = argparse.ArgumentParser(description="Expiry test")
_parser.add_argument("--base-url", default=None)
_parser.add_argument("--ttl", type=int, default=None)
_args, _unknown = _parser.parse_known_args()
sys.argv = [sys.argv[0]] + _unknown
BASE_URL = (_args.base_url or os.environ.get("BASE_URL") or "http://localhost:8080").rstrip("/")
TTL = _args.ttl or int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
def request(method, path, body=None, token=None, basic=None):
headers = {"Accept": "application/json"}
if token:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + basic
data = None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
headers["Content-Type"] = "application/json"
req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
payload = resp.read()
return resp.status, json.loads(payload) if payload else None
except urllib.error.HTTPError as err:
payload = err.read()
return err.code, json.loads(payload) if payload else None
@unittest.skipIf(
TTL > 10,
"SESSION_TTL_SECONDS > 10; запустите стенд с коротким TTL и передайте "
"SESSION_TTL_SECONDS=2 make test-expiry",
)
class ExpiryTests(unittest.TestCase):
def test_session_expires(self):
username = "u_exp_" + uuid.uuid4().hex[:10]
password = "T3st-" + uuid.uuid4().hex
status, user = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Expiry", "password": password},
)
self.assertEqual(status, 201, user)
basic = base64.b64encode((username + ":" + password).encode()).decode()
status, session = request("POST", "/api/v1/auth/sessions", basic=basic)
self.assertEqual(status, 201, session)
token = session["token"]
# Проверяем, что API реально запущен с коротким TTL: иначе тест
# будет ждать час и всё равно упадёт.
expires_at = session["expires_at"]
from datetime import datetime, timezone
exp = datetime.strptime(expires_at, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
actual_ttl = (exp - datetime.now(timezone.utc)).total_seconds()
self.assertLessEqual(
actual_ttl,
10,
"API запущен с TTL=" + str(int(actual_ttl)) + "s; перезапустите стенд с "
"SESSION_TTL_SECONDS=2 (например: SESSION_TTL_SECONDS=2 docker compose up -d api)",
)
status, _ = request("GET", "/api/v1/users/me", token=token)
self.assertEqual(status, 200)
time.sleep(actual_ttl + 2)
status, body = request("GET", "/api/v1/users/me", token=token)
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
# Повторный вход с теми же credentials снова работает.
status, session2 = request("POST", "/api/v1/auth/sessions", basic=basic)
self.assertEqual(status, 201, session2)
status, _ = request("GET", "/api/v1/users/me", token=session2["token"])
self.assertEqual(status, 200)
if __name__ == "__main__":
unittest.main(verbosity=2)
+338
View File
@@ -0,0 +1,338 @@
#!/usr/bin/env python3
"""Собственные тесты уровня 4: негативные сценарии и конкурентная запись.
Запуск: python3 tests/test_unit.py
Требует запущенный сервер (по умолчанию http://localhost:8080).
"""
import argparse
import base64
import json
import os
import sys
import threading
import unittest
import urllib.error
import urllib.request
import uuid
_parser = argparse.ArgumentParser(description="Собственные тесты уровня 4")
_parser.add_argument("--base-url", default=None)
_args, _unknown = _parser.parse_known_args()
# unittest.main() читает sys.argv сам и не знает про --base-url — убираем его.
sys.argv = [sys.argv[0]] + _unknown
BASE_URL = (
_args.base_url
or os.environ.get("BASE_URL")
or "http://localhost:8080"
).rstrip("/")
def request(method, path, body=None, token=None, raw=None, content_type="application/json",
basic=None, extra_headers=None):
headers = {"Accept": "application/json"}
if token:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + basic
if extra_headers:
headers.update(extra_headers)
data = None
if raw is not None:
data = raw
headers["Content-Type"] = content_type
elif body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
headers["Content-Type"] = "application/json"
req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
payload = resp.read()
return resp.status, json.loads(payload) if payload else None
except urllib.error.HTTPError as err:
payload = err.read()
return err.code, json.loads(payload) if payload else None
def make_user(label):
username = "u_" + label + "_" + uuid.uuid4().hex[:10]
password = "T3st-" + uuid.uuid4().hex
status, user = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Тест " + label, "password": password},
)
assert status == 201, (status, user)
basic = base64.b64encode((username + ":" + password).encode()).decode()
status, session = request("POST", "/api/v1/auth/sessions", basic=basic)
assert status == 201, (status, session)
return {"user": user, "token": session["token"], "basic": basic, "password": password}
class MessengerTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.alice = make_user("alice")
cls.bob = make_user("bob")
cls.eve = make_user("eve")
status, chat = request(
"POST",
"/api/v1/chats",
{"title": "Тестовый чат", "member_ids": [cls.alice["user"]["id"], cls.bob["user"]["id"]]},
token=cls.alice["token"],
)
assert status == 201, (status, chat)
cls.chat = chat
def test_invalid_json(self):
status, body = request(
"POST",
"/api/v1/chats/" + self.chat["id"] + "/messages",
raw=b"{not json",
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_foreign_chat_returns_404(self):
status, body = request("GET", "/api/v1/chats/" + self.chat["id"], token=self.eve["token"])
self.assertEqual(status, 404)
self.assertEqual(body["error"]["code"], "not_found")
def test_empty_message_rejected(self):
status, body = request(
"POST",
"/api/v1/chats/" + self.chat["id"] + "/messages",
{"text": " "},
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_duplicate_username(self):
username = "u_dup_" + uuid.uuid4().hex[:10]
password = "T3st-" + uuid.uuid4().hex
first = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Первый", "password": password},
)
self.assertEqual(first[0], 201)
second = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Второй", "password": password},
)
self.assertEqual(second[0], 409)
self.assertEqual(second[1]["error"]["code"], "conflict")
def test_short_password_rejected(self):
status, body = request(
"POST",
"/api/v1/users",
{"username": "u_short_" + uuid.uuid4().hex[:8], "display_name": "X", "password": "short"},
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_wrong_password_returns_401(self):
bad = base64.b64encode(
(self.alice["user"]["username"] + ":wrong-password-123").encode()
).decode()
status, body = request("POST", "/api/v1/auth/sessions", basic=bad)
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
def test_basic_not_accepted_on_business_endpoint(self):
status, body = request("GET", "/api/v1/users/me", basic=self.alice["basic"])
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
def test_x_user_id_ignored(self):
status, body = request(
"GET",
"/api/v1/users/me",
token=self.alice["token"],
extra_headers={"X-User-Id": self.eve["user"]["id"]},
)
self.assertEqual(status, 200)
self.assertEqual(body["id"], self.alice["user"]["id"])
def test_logout_revokes_session(self):
user = make_user("logout")
status, _ = request("DELETE", "/api/v1/auth/sessions/current", token=user["token"])
self.assertEqual(status, 204)
status, body = request("GET", "/api/v1/users/me", token=user["token"])
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
def test_pagination_walks_all_pages(self):
chat = request(
"POST",
"/api/v1/chats",
{"title": "Пагинация", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
token=self.alice["token"],
)[1]
sent = []
for i in range(7):
status, msg = request(
"POST",
"/api/v1/chats/" + chat["id"] + "/messages",
{"text": "msg-%d" % i},
token=self.alice["token"],
)
self.assertEqual(status, 201)
sent.append(msg["id"])
collected = []
cursor = None
while True:
path = "/api/v1/chats/" + chat["id"] + "/messages?limit=2"
if cursor:
path += "&cursor=" + cursor
status, page = request("GET", path, token=self.bob["token"])
self.assertEqual(status, 200)
collected.extend(m["id"] for m in page["items"])
cursor = page["next_cursor"]
if not cursor:
break
self.assertEqual(collected, sent)
def test_cursor_bound_to_resource(self):
chat_a = request(
"POST",
"/api/v1/chats",
{"title": "Cursor A", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
token=self.alice["token"],
)[1]
chat_b = request(
"POST",
"/api/v1/chats",
{"title": "Cursor B", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
token=self.alice["token"],
)[1]
for i in range(3):
request(
"POST",
"/api/v1/chats/" + chat_a["id"] + "/messages",
{"text": "a-%d" % i},
token=self.alice["token"],
)
status, page = request(
"GET",
"/api/v1/chats/" + chat_a["id"] + "/messages?limit=1",
token=self.alice["token"],
)
self.assertEqual(status, 200)
cursor = page["next_cursor"]
self.assertIsNotNone(cursor)
status, body = request(
"GET",
"/api/v1/chats/" + chat_b["id"] + "/messages?limit=1&cursor=" + cursor,
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_cursor_bound_to_endpoint(self):
status, page = request(
"GET", "/api/v1/chats?limit=1", token=self.alice["token"]
)
self.assertEqual(status, 200)
cursor = page["next_cursor"]
self.assertIsNotNone(cursor)
status, body = request(
"GET",
"/api/v1/chats/" + self.chat["id"] + "/messages?limit=1&cursor=" + cursor,
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_cursor_garbage_rejected(self):
garbage = base64.urlsafe_b64encode(b"x|y").decode("ascii")
status, body = request(
"GET",
"/api/v1/chats/" + self.chat["id"] + "/messages?cursor=" + garbage,
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_invalid_chat_id_returns_400(self):
status, body = request("GET", "/api/v1/chats/not-a-uuid", token=self.alice["token"])
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
status, body = request(
"POST",
"/api/v1/chats/not-a-uuid/messages",
{"text": "hi"},
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
status, body = request(
"GET", "/api/v1/chats/not-a-uuid/messages", token=self.alice["token"]
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_username_with_trailing_newline_rejected(self):
status, body = request(
"POST",
"/api/v1/users",
{"username": "abc\n", "display_name": "Имя", "password": "T3st-" + uuid.uuid4().hex},
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_invalid_body_bytes_contract_error(self):
status, body = request(
"POST",
"/api/v1/users",
raw=b"\xff",
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
self.assertIn("message", body["error"])
self.assertIn("request_id", body["error"])
def test_concurrent_writes_are_unique(self):
chat = request(
"POST",
"/api/v1/chats",
{"title": "Конкурентность", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
token=self.alice["token"],
)[1]
errors = []
lock = threading.Lock()
def worker(worker_id):
for i in range(10):
status, body = request(
"POST",
"/api/v1/chats/" + chat["id"] + "/messages",
{"text": "w%d-%d" % (worker_id, i)},
token=self.alice["token"],
)
if status != 201:
with lock:
errors.append((status, body))
threads = [threading.Thread(target=worker, args=(w,)) for w in range(10)]
for t in threads:
t.start()
for t in threads:
t.join()
self.assertEqual(errors, [])
status, page = request(
"GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100", token=self.alice["token"]
)
self.assertEqual(status, 200)
ids = [m["id"] for m in page["items"]]
self.assertEqual(len(ids), 100)
self.assertEqual(len(set(ids)), 100)
if __name__ == "__main__":
unittest.main(verbosity=2)