50 changed files with 1434 additions and 47 deletions
+5 -11
View File
@@ -1,13 +1,7 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
# Local-only values for a synthetic учебный стенд. Do not commit a real .env.
POSTGRES_USER=messenger
POSTGRES_PASSWORD=Local-Only-Example-Change-Me-123
POSTGRES_DB=messenger
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
LB_PORT=8080
+2
View File
@@ -0,0 +1,2 @@
* text=auto
*.sh text eol=lf
+14 -14
View File
@@ -1,18 +1,18 @@
## Лабораторная 3
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Автор / группа: Федотов Михаил БВТ2302
Целевая оценка (3/4/5): 3
Трек 5, если заявлен: не заявлен
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
Что реализовано и что перенесено: Перенесён обязательный API Lab 2: PostgreSQL, Argon2id, Basic→Bearer-сессии в Redis, чаты и история сообщений. Добавлены два stateless API за Nginx, общий PostgreSQL/Redis, однократный runner миграций, заголовок X-Instance-Id, атомарная идемпотентность POST сообщений и restart/failover hooks.
Команды запуска из чистого clone: `cp .env.example .env`; `docker compose --env-file .env up -d --build --scale api=2`; `make check`; `make test`; `make test-idempotency`; `make test-persistence ACTION_SCRIPT=scripts/restart.sh`; `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`.
Результаты проверок и ссылка на REPORT.md: `make check`, `make validate`, `make test`, persistence, failover и конкурентная идемпотентность прошли. Подробности и обезличенные stdout: [REPORT.md](../REPORT.md), `evidence/`.
Ограничения / известные ошибки: Один Docker-host, LB и БД остаются SPOF; лабораторный HTTP только для localhost; уровень 4/5 не заявляется.
Источники и использование ИИ: Собственный исходный код из Lab 2; использовалась помощь ИИ при адаптации и проверке.
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
- [x] Обязательный минимум предыдущей и текущей работ сохранён с переходом Lab 2 → Lab 3.
- [x] Контракт и публичные тесты не ослаблены.
- [x] `make check` и `make test` выполнены; выводы находятся в `evidence/`.
- [x] Persistence- и failover-сценарии уровня 3 воспроизведены; результат failover приложен.
- [x] Секреты и приватные ключи вне Git; доказательства не содержат tokens.
- [x] README задания сохранён, [REPORT.md](../REPORT.md) содержит инструкцию этого решения.
+16
View File
@@ -0,0 +1,16 @@
FROM python:3.12.8-slim
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1
WORKDIR /app
COPY requirements-app.txt ./
RUN pip install --no-cache-dir -r requirements-app.txt
COPY app ./app
COPY migrations ./migrations
COPY scripts ./scripts
RUN useradd --create-home --uid 10001 appuser
USER appuser
EXPOSE 8080
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
+13 -4
View File
@@ -4,10 +4,10 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence test-failover
.PHONY: help check validate test test-idempotency load test-persistence test-failover up down
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "up: build and start PostgreSQL, Redis, 2 API replicas and Nginx; test: public smoke"
check:
$(PYTHON) scripts/check_contract.py
@@ -15,16 +15,25 @@ check:
validate:
$(PYTHON) scripts/validate_openapi.py
up:
docker compose --env-file .env up -d --build --scale api=2
down:
docker compose down
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-idempotency:
$(PYTHON) tests/idempotency.py --base-url "$(BASE_URL)" $(TLS_ARGS)
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to scripts/restart.sh"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to scripts/stop-one.sh"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
+73 -18
View File
@@ -1,37 +1,92 @@
# Отчёт — лабораторная 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Федотов Михаил, БВТ2302
- Целевая оценка: 3
- Трек 5: не заявлен
- Проверенная ревизия исходников перед объединением истории: `a74e32e`; файлы приложения и Compose после проверок не менялись.
- Источники и библиотеки: собственная реализация из Lab 2; FastAPI 0.115.6, Uvicorn 0.34.0, asyncpg 0.30.0, redis-py 5.2.1, Argon2id через argon2-cffi 23.1.0. При разработке использовалась помощь ИИ.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Требуются Docker Engine с Compose v2, GNU Make, Python 3.12+ для локальных команд и свободный `127.0.0.1:8080`. Образы закреплены в `compose.yaml` и `Dockerfile`.
```sh
cp .env.example .env
# При необходимости замените POSTGRES_PASSWORD на локальное значение из букв/цифр/дефиса.
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --scale api=2
docker compose ps
make check
make test
make test-idempotency
```
Однократный сервис `migrate` ждёт здоровую PostgreSQL и применяет SQL-миграции до запуска API. Не запускайте миграции вручную одновременно с несколькими репликами. Дождитесь `healthy` для `postgres`, `redis`, обеих строк `api` и `lb`. Основной адрес по умолчанию — `http://localhost:8080` через Nginx; если Lab 2 уже занимает этот порт, задайте `LB_PORT=8081` в локальном `.env` и запускайте тесты с `BASE_URL=http://localhost:8081`; внутренние порты API, PostgreSQL и Redis на host не опубликованы.
Проверка сохранности (создаёт синтетические данные, проверяет прежний токен):
```sh
chmod +x scripts/restart.sh
make test-persistence ACTION_SCRIPT=scripts/restart.sh
```
Проверка отказа одной API-реплики:
```sh
chmod +x scripts/stop-one.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
# Failover-тест намеренно оставляет выбранную реплику остановленной.
docker compose start api
docker compose ps
```
`docker compose down` останавливает стенд, но сохраняет именованные volumes. Для осознанного сброса только учебных данных используйте `docker compose down -v`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Клиент → Nginx (`lb`) → две stateless API-реплики `api` → общие PostgreSQL и Redis. Nginx разрешает адреса сервиса API через Docker DNS и использует пассивное исключение отказавшего backend; sticky sessions нет. API сообщает стабильный `X-Instance-Id` (hostname контейнера) и уникальный для ответа `X-Request-Id`.
## Доказательства критериев
Из Lab 2 перенесены регистрация с Argon2id, вход Basic только на `/auth/sessions`, непрозрачные Bearer-сессии в общем Redis с TTL, logout, PostgreSQL для пользователей/чатов/участников/сообщений, keyset-пагинация, ограничения пула, параметризованные запросы и ошибки API. Переход Lab 2 → Lab 3 добавляет обязательный `Idempotency-Key` на POST сообщения и `X-Instance-Id` в API-ответах.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
Миграции выполняет единственный Compose-сервис `migrate` до запуска API. Таблица `message_idempotency` хранит уникальный ключ в области пользователя и чата, SHA-256 канонического JSON тела, ссылку на созданное сообщение и время создания. PostgreSQL advisory lock сериализует повтор одного ключа между репликами. Создание сообщения и сохранение результата происходят в одной транзакции. Повтор того же тела в течение 24 часов возвращает тот же объект; другое тело даёт 409. Просроченные записи очищаются пакетами. Если ответ потерялся после COMMIT, клиент может повторить POST с прежним ключом.
PostgreSQL — источник истины для постоянных данных; именованный том `postgres_data`. Redis хранит общие сессии с абсолютным expiry; включены AOF `appendfsync always` и том `redis_data`. Logout отзывает токен. Потеря PostgreSQL или Redis делает readiness отрицательной; `X-User-Id` не используется для авторизации.
### Карта инфраструктуры
| Роль | Compose service и версия | Health/readiness | Volume | Сеть/порты | Передача credentials |
| --- | --- | --- | --- | --- | --- |
| API, две реплики | `api`, сборка Dockerfile на `python:3.12.8-slim`; зависимости зафиксированы в `requirements-app.txt` | Docker healthcheck опрашивает `/health/ready` | Нет, API stateless | Внутренняя сеть Compose, порт 8080 не опубликован | Compose формирует `DATABASE_URL` из локального `.env`; Redis по внутреннему `REDIS_URL` |
| PostgreSQL | `postgres:16.4-alpine` | `pg_isready` | Именованный `postgres_data` → `/var/lib/postgresql/data` | Только внутренняя сеть, host port не опубликован | `POSTGRES_USER`, `POSTGRES_PASSWORD`, `POSTGRES_DB` из локального `.env` |
| Хранилище сессий | `redis:7.4.2-alpine` | `redis-cli ping`; API readiness проверяет Redis | Именованный `redis_data` → `/data`, AOF `appendfsync always` | Только внутренняя сеть, host port не опубликован | Пароль не задан; Redis не опубликован на host и доступен только внутри Compose-сети |
| Балансировщик | `nginx:1.27.4-alpine` | GET `/health/ready` через Nginx | Только readonly bind mount `nginx/default.conf` | Публичный учебный entrypoint `127.0.0.1:8081:8080` | Не нужны |
| Однократные миграции | `migrate`, сборка того же Dockerfile и образа Python | Завершение команды с exit 0; запускается до API | Нет | Внутренняя сеть, без опубликованного порта | `DATABASE_URL` формируется из того же локального `.env` |
## Результаты и доказательства
| Критерий | Проверка | Результат | Файл |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Структура, локальные refs и синтаксис публичных проверок | `make check` | PASS | `evidence/make-check.txt` |
| OpenAPI 3.1 и JSON Schema | `make validate` | PASS | `evidence/make-validate.txt` |
| Сборка Compose и readiness | `docker compose ... config --quiet`, `docker compose ps` | PASS: 2 API, PostgreSQL, Redis, Nginx healthy | `evidence/compose-config.txt`, `evidence/compose-start.txt` |
| Lab 2 API smoke с переходом Lab 3 | `make test` | PASS: пользователи, Basic/Bearer, чаты, история, ACL, logout, повторы | `evidence/make-test.txt` |
| Конкурентный ключ через разные реплики | `make test-idempotency` | PASS: 16 запросов через 2 `X-Instance-Id` вернули один объект; другое тело — 409 | `evidence/make-test-idempotency.txt` |
| Полный restart с прежней сессией | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS: данные и прежний токен остались действительны | `evidence/test-persistence.txt` |
| Остановка одной реплики | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | PASS: 2 реплики наблюдались до отказа, первая запись после отказа за 0,673 с, подтверждённые сообщения сохранены | `evidence/test-failover.txt` |
| Идемпотентность bootstrap миграций | Повторный запуск `migrate` дважды | PASS: применены только версии 1, 2, 3 | `evidence/migrations-repeat.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Публичные `README.md`, `contracts/` и `tests/` сохранены. В `evidence/` записаны обезличенные команды/результаты и профиль; токенов, `.env` и Authorization headers там нет.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Целевой уровень — 3; трек 5 и требования уровня 4 не заявляются. В тесте отказа одна выбранная API-реплика была остановлена, Nginx направлял новые обращения к оставшейся. В более раннем прогоне была одна временная ошибка; финальный прогон через tracked POSIX hook завершился без ошибок, первая успешная запись после отказа — через 0,673 с. Публичный resilience driver повторял неопределённые POST с тем же ключом и проверил историю на потерянные подтверждения и дубли. Отказ Docker-host, LB, PostgreSQL или Redis тестом не проверялся.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| Воздействие | Ожидаемый результат | Наблюдение | Восстановление / сохранность |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| 16 одинаковых POST одновременно | Один побочный эффект, идентичный ответ; иная нагрузка с ключом — 409 | PASS на 2 разных репликах | Один объект в истории |
| Остановка одной API | Другая реплика принимает записи ≤10 секунд | PASS; 0,673 с до первой успешной записи | Реплика восстановлена оператором; потерь подтверждённых данных не было |
| Перезапуск API, PostgreSQL и Redis | Прежний токен и данные работают без повторного входа | PASS | Named volumes сохранены |
## Ограничения и следующие шаги
## Ограничения
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Стенд работает на одном Docker-host с одним LB, PostgreSQL и Redis, поэтому отказ этих узлов не переживается. Nginx использует пассивное исключение backend, а не отдельный активный health-check сервис. Уровень 4 (поочерёдная остановка каждой реплики с профилированием, rolling update) и уровень 5 не выполнялись. HTTP предназначен только для локального стенда с синтетическими данными.
View File
View File
+42
View File
@@ -0,0 +1,42 @@
from fastapi import Request
from app.core.errors import ApiError
from app.repositories.memory import SessionRow, UserRow
import uuid as _uuid
BEARER_CHALLENGE = {'WWW-Authenticate': 'Bearer realm="messenger"'}
def storage_of(request: Request):
return request.app.state.storage
async def current_session(request: Request) -> SessionRow:
header = request.headers.get('authorization', '')
token = header[7:].strip() if header[:7].lower() == 'bearer ' else ''
if not token:
raise ApiError(401, 'Bearer session required', headers=BEARER_CHALLENGE)
row = await storage_of(request).session(token)
if row is None:
raise ApiError(401, 'Session is missing, expired or revoked', headers=BEARER_CHALLENGE)
return row
async def current_user(request: Request) -> UserRow:
session = await current_session(request)
user = await storage_of(request).user(session.user_id)
if user is None:
raise ApiError(401, 'Session user no longer exists', headers=BEARER_CHALLENGE)
return user
async def require_chat_member(request: Request, chat_id: str, user: UserRow):
try:
_uuid.UUID(chat_id)
except ValueError:
raise ApiError(400, 'chat_id must be a UUID')
row = await storage_of(request).chat(chat_id)
if row is None or user.id not in row.member_ids:
raise ApiError(404, 'Chat is not available for this user')
return row
View File
+31
View File
@@ -0,0 +1,31 @@
from fastapi import APIRouter, Request
from fastapi.responses import Response
from app.api.deps import current_session
from app.api.serialize import user_out
from app.core.config import settings
from app.core.errors import ApiError
from app.core.security import parse_basic, verify_password
from app.repositories.memory import iso_z
router = APIRouter()
BASIC_CHALLENGE = {'WWW-Authenticate': 'Basic realm="messenger", charset="UTF-8"'}
@router.post('/api/v1/auth/sessions', status_code=201)
async def login(request: Request):
creds = parse_basic(request.headers.get('authorization', ''))
storage = request.app.state.storage
row = await storage.user_by_username(creds[0]) if creds else None
if creds is None or row is None or not verify_password(row.password_hash, creds[1]):
raise ApiError(401, 'Invalid credentials', headers=BASIC_CHALLENGE)
session = await storage.create_session(row.id, settings.session_ttl_seconds)
return {'token': session.token, 'token_type': 'Bearer',
'expires_at': iso_z(session.expires_at), 'user': user_out(row)}
@router.delete('/api/v1/auth/sessions/current', status_code=204)
async def logout(request: Request):
session = await current_session(request)
await request.app.state.storage.revoke(session.token)
return Response(status_code=204)
+33
View File
@@ -0,0 +1,33 @@
from fastapi import APIRouter, Query, Request
from app.api.deps import current_user, require_chat_member
from app.api.serialize import chat_out
from app.core.cursors import decode_cursor, paginate
from app.schemas import CreateChat
router = APIRouter()
@router.post('/api/v1/chats', status_code=201)
async def create_chat(body: CreateChat, request: Request):
user = await current_user(request)
member_ids = [str(mid) for mid in body.member_ids]
row = await request.app.state.storage.create_chat(body.title, member_ids, user.id)
return chat_out(row)
@router.get('/api/v1/chats')
async def list_chats(request: Request, limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1)):
user = await current_user(request)
resource = 'chats:' + user.id
key = decode_cursor(cursor, resource) if cursor else None
rows = await request.app.state.storage.chats_of(user.id)
page, next_cursor = paginate(rows, key, limit, resource)
return {'items': [chat_out(r) for r in page], 'next_cursor': next_cursor}
@router.get('/api/v1/chats/{chat_id}')
async def get_chat(chat_id: str, request: Request):
user = await current_user(request)
return chat_out(await require_chat_member(request, chat_id, user))
+17
View File
@@ -0,0 +1,17 @@
from fastapi import APIRouter, Request
from app.core.errors import ApiError
router = APIRouter()
@router.get('/health/live')
async def live():
return {'status': 'ok'}
@router.get('/health/ready')
async def ready(request: Request):
if not await request.app.state.storage.ready():
raise ApiError(503, 'Storage is unavailable')
return {'status': 'ok'}
+11
View File
@@ -0,0 +1,11 @@
from fastapi import APIRouter, Request
from app.api.deps import current_user
from app.api.serialize import user_out
router = APIRouter()
@router.get('/api/v1/users/me')
async def me(request: Request):
return user_out(await current_user(request))
+51
View File
@@ -0,0 +1,51 @@
import hashlib
import json
from fastapi import APIRouter, Header, Query, Request
from app.api.deps import current_user, require_chat_member
from app.api.serialize import message_out
from app.core.cursors import decode_cursor, encode_cursor
from app.core.errors import ApiError
from app.schemas import CreateMessage
router = APIRouter()
@router.post('/api/v1/chats/{chat_id}/messages', status_code=201)
async def create_message(
body: CreateMessage,
chat_id: str,
request: Request,
idempotency_key: str | None = Header(
default=None, alias='Idempotency-Key', min_length=1, max_length=128,
pattern=r'^[A-Za-z0-9._:-]{1,128}$',
),
):
if idempotency_key is None:
raise ApiError(400, 'Idempotency-Key is required')
user = await current_user(request)
chat = await require_chat_member(request, chat_id, user)
normalized_body = json.dumps(
body.model_dump(mode='json'), ensure_ascii=False, sort_keys=True, separators=(',', ':')
).encode('utf-8')
body_hash = hashlib.sha256(normalized_body).digest()
row = await request.app.state.storage.add_idempotent_message(
chat.id, user.id, body.text, idempotency_key, body_hash,
)
return message_out(row)
@router.get('/api/v1/chats/{chat_id}/messages')
async def list_messages(request: Request, chat_id: str,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1)):
user = await current_user(request)
chat = await require_chat_member(request, chat_id, user)
resource = 'messages:' + chat.id
key = decode_cursor(cursor, resource) if cursor else None
rows, has_more = await request.app.state.storage.messages_page(chat.id, key, limit)
next_cursor = (
encode_cursor(resource, rows[-1].created_at, rows[-1].id)
if has_more else None
)
return {'items': [message_out(row) for row in rows], 'next_cursor': next_cursor}
+14
View File
@@ -0,0 +1,14 @@
from fastapi import APIRouter, Request
from app.api.serialize import user_out
from app.core.security import hash_password
from app.schemas import CreateUser
router = APIRouter()
@router.post('/api/v1/users', status_code=201)
async def register(body: CreateUser, request: Request):
row = await request.app.state.storage.create_user(
body.username, body.display_name, hash_password(body.password))
return user_out(row)
+15
View File
@@ -0,0 +1,15 @@
from app.repositories.memory import UserRow
def user_out(row: UserRow) -> dict:
return {'id': row.id, 'username': row.username,
'display_name': row.display_name, 'created_at': row.created_at}
def chat_out(row) -> dict:
return {'id': row.id, 'title': row.title,
'member_ids': list(row.member_ids), 'created_at': row.created_at}
def message_out(row) -> dict:
return {'id': row.id, 'chat_id': row.chat_id, 'sender_id': row.sender_id,
'text': row.text, 'created_at': row.created_at}
View File
+31
View File
@@ -0,0 +1,31 @@
from pathlib import Path
from pydantic_settings import BaseSettings, SettingsConfigDict
class Settings(BaseSettings):
model_config = SettingsConfigDict(env_file='.env', extra='ignore')
app_host: str = '0.0.0.0'
app_port: int = 8080
session_ttl_seconds: int = 3600
database_url: str = ''
database_url_file: str | None = None
redis_url: str = 'redis://localhost:6379/0'
redis_url_file: str | None = None
db_pool_min_size: int = 1
db_pool_max_size: int = 10
db_pool_acquire_timeout_seconds: float = 3.0
db_command_timeout_seconds: float = 5.0
redis_timeout_seconds: float = 2.0
def resolved_database_url(self) -> str:
if self.database_url_file:
return Path(self.database_url_file).read_text(encoding='utf-8').strip()
return self.database_url
def resolved_redis_url(self) -> str:
if self.redis_url_file:
return Path(self.redis_url_file).read_text(encoding='utf-8').strip()
return self.redis_url
settings = Settings()
+37
View File
@@ -0,0 +1,37 @@
import base64
import binascii
import json
import uuid
from datetime import datetime
from app.core.errors import ApiError
from app.repositories.memory import order_key
def encode_cursor(resource: str, created_at: str, row_id: str) -> str:
payload = json.dumps({'r': resource, 't': created_at, 'i': row_id}, separators=(',', ':'))
return base64.urlsafe_b64encode(payload.encode()).decode()
def decode_cursor(value: str, resource: str) -> tuple[datetime, int]:
"""Курсор от другого ресурса или битый -> 400 invalid_request."""
try:
payload = json.loads(base64.urlsafe_b64decode(value.encode()))
if payload['r'] != resource:
raise ValueError('cursor belongs to another resource')
moment = datetime.fromisoformat(payload['t'].replace('Z', '+00:00'))
return moment, uuid.UUID(payload['i']).int
except (ValueError, KeyError, TypeError, binascii.Error):
raise ApiError(400, 'Invalid cursor')
def paginate(rows: list, cursor_key, limit: int, resource: str):
"""Keyset: берём строки строго после (created_at, id) курсора, без offset-скана."""
if cursor_key is not None:
rows = [r for r in rows if order_key(r.created_dt, r.id) > cursor_key]
page = rows[:limit]
next_cursor = None
if len(rows) > limit: # следующая запись есть на момент чтения
last = page[-1]
next_cursor = encode_cursor(resource, last.created_at, last.id)
return page, next_cursor
+72
View File
@@ -0,0 +1,72 @@
import os
import socket
import uuid
import asyncpg
from redis.exceptions import RedisError
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
from starlette.middleware.base import BaseHTTPMiddleware
CODES = {400: 'invalid_request', 401: 'unauthorized', 404: 'not_found', 409: 'conflict',
413: 'payload_too_large', 415: 'unsupported_media_type', 429: 'rate_limited',
503: 'unavailable', 500: 'internal_error'}
class ApiError(Exception):
"""Бизнес-ошибка: HTTP-статус + код контракта + безопасное сообщение."""
def __init__(self, status_code: int, message: str, code: str | None = None,
headers: dict | None = None):
self.status_code = status_code
self.code = code or CODES.get(status_code, 'internal_error')
self.message = message
self.headers = headers or {}
class RequestIdMiddleware(BaseHTTPMiddleware):
"""Каждый ответ, включая 204 и ошибки, несёт непустой X-Request-Id."""
async def dispatch(self, request: Request, call_next):
request.state.request_id = str(uuid.uuid4())
response = await call_next(request)
response.headers['X-Request-Id'] = request.state.request_id
response.headers['X-Instance-Id'] = os.environ.get('INSTANCE_ID') or socket.gethostname()
return response
def _body(request: Request, status_code: int, code: str, message: str,
headers: dict | None = None) -> JSONResponse:
rid = getattr(request.state, 'request_id', str(uuid.uuid4()))
return JSONResponse(status_code=status_code, headers=headers,
content={'error': {'code': code, 'message': message, 'request_id': rid}})
def register_error_handlers(app: FastAPI) -> None:
@app.exception_handler(ApiError)
async def on_api_error(request: Request, exc: ApiError):
return _body(request, exc.status_code, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def on_validation(request: Request, exc: RequestValidationError):
return _body(request, 400, 'invalid_request', 'Request validation failed')
@app.exception_handler(StarletteHTTPException)
async def on_http(request: Request, exc: StarletteHTTPException):
code = CODES.get(exc.status_code, 'invalid_request')
return _body(request, exc.status_code, code, 'Route or method not found')
async def on_dependency_failure(request: Request, exc: Exception):
return _body(request, 503, 'unavailable', 'A required service is unavailable')
app.add_exception_handler(asyncpg.PostgresError, on_dependency_failure)
app.add_exception_handler(RedisError, on_dependency_failure)
app.add_exception_handler(OSError, on_dependency_failure)
app.add_exception_handler(TimeoutError, on_dependency_failure)
@app.exception_handler(Exception)
async def on_unexpected(request: Request, exc: Exception):
return _body(request, 500, 'internal_error', 'Internal error')
+39
View File
@@ -0,0 +1,39 @@
import base64
import binascii
import secrets
from argon2 import PasswordHasher
from argon2.exceptions import Argon2Error
_ph = PasswordHasher() # по умолчанию Argon2id
def hash_password(password: str) -> str:
return _ph.hash(password)
def verify_password(digest: str, password: str) -> bool:
try:
return _ph.verify(digest, password)
except (Argon2Error, ValueError):
return False
def new_token() -> str:
return secrets.token_hex(32) # 32 байта = 256 бит энтропии
def parse_basic(header: str) -> tuple[str, str] | None:
"""Преобразовать 'Basic base64(username:password)' в пару (username, password) или вернуть None."""
parts = header.split(' ', 1)
if len(parts) != 2 or parts[0].lower() != 'basic':
return None
try:
raw = base64.b64decode(parts[1].strip(), validate=True)
text = raw.decode('utf-8')
except (binascii.Error, ValueError, UnicodeDecodeError):
return None
if ':' not in text:
return None
username, password = text.split(':', 1) # двоеточие в пароле допустимо
return username, password
+1
View File
@@ -0,0 +1 @@
"""Настройка базы данных и миграции схемы."""
+56
View File
@@ -0,0 +1,56 @@
from pathlib import Path
import asyncpg
MIGRATIONS_DIR = Path(__file__).resolve().parents[2] / 'migrations'
async def apply_migrations(pool: asyncpg.Pool) -> None:
"""Применить каждую нумерованную SQL-миграцию один раз в транзакции под advisory lock."""
async with pool.acquire() as connection:
await connection.execute('SELECT pg_advisory_lock($1)', 762019002)
try:
await connection.execute(
'CREATE TABLE IF NOT EXISTS schema_migrations ('
' version integer PRIMARY KEY,'
' applied_at timestamptz NOT NULL DEFAULT now())'
)
applied = {
row['version']
for row in await connection.fetch('SELECT version FROM schema_migrations')
}
for path in sorted(MIGRATIONS_DIR.glob('[0-9]*_*.sql')):
version = int(path.name.split('_', 1)[0])
if version in applied:
continue
async with connection.transaction():
await connection.execute(path.read_text(encoding='utf-8'))
await connection.execute(
'INSERT INTO schema_migrations (version) VALUES ($1)', version
)
finally:
await connection.execute('SELECT pg_advisory_unlock($1)', 762019002)
async def _main() -> None:
import asyncio
from app.core.config import settings
dsn = settings.resolved_database_url()
if not dsn:
raise RuntimeError('Set DATABASE_URL or DATABASE_URL_FILE before running migrations')
pool = await asyncpg.create_pool(
dsn,
min_size=settings.db_pool_min_size,
max_size=settings.db_pool_max_size,
timeout=settings.db_pool_acquire_timeout_seconds,
command_timeout=settings.db_command_timeout_seconds,
)
try:
await apply_migrations(pool)
finally:
await pool.close()
if __name__ == '__main__':
import asyncio
asyncio.run(_main())
+52
View File
@@ -0,0 +1,52 @@
from contextlib import asynccontextmanager
import asyncpg
from fastapi import FastAPI
from redis.asyncio import Redis
from app.api.routes import auth, health, me, users, chats, messages
from app.core.config import settings
from app.core.errors import RequestIdMiddleware, register_error_handlers
from app.repositories.postgres import PgStorage
from app.repositories.redis_sessions import RedisSessionStore
def create_app() -> FastAPI:
@asynccontextmanager
async def lifespan(app: FastAPI):
dsn = settings.resolved_database_url()
if not dsn:
raise RuntimeError('Set DATABASE_URL or DATABASE_URL_FILE before starting the API')
pool = await asyncpg.create_pool(
dsn,
min_size=settings.db_pool_min_size,
max_size=settings.db_pool_max_size,
timeout=settings.db_pool_acquire_timeout_seconds,
command_timeout=settings.db_command_timeout_seconds,
)
redis_client = Redis.from_url(
settings.resolved_redis_url(),
decode_responses=True,
socket_connect_timeout=settings.redis_timeout_seconds,
socket_timeout=settings.redis_timeout_seconds,
)
try:
app.state.storage = PgStorage(pool, RedisSessionStore(redis_client))
yield
finally:
await redis_client.aclose()
await pool.close()
app = FastAPI(title='MTUSI Messenger lab3', docs_url=None, redoc_url=None, lifespan=lifespan)
app.add_middleware(RequestIdMiddleware)
register_error_handlers(app)
app.include_router(health.router)
app.include_router(users.router)
app.include_router(me.router)
app.include_router(auth.router)
app.include_router(chats.router)
app.include_router(messages.router)
return app
app = create_app()
View File
+149
View File
@@ -0,0 +1,149 @@
import threading
import uuid
from dataclasses import dataclass, field
from datetime import datetime, timedelta, timezone
from app.core.errors import ApiError
def now_utc() -> datetime:
return datetime.now(timezone.utc)
def iso_z(moment: datetime) -> str:
"""RFC 3339 UTC с Z и микросекундами: порядок (created_at, id) не теряет точность."""
return moment.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
def order_key(created_dt: datetime, row_id: str):
"""Контракт: порядок по (created_at, id), id сравнивается как значение UUID."""
return (created_dt, uuid.UUID(row_id).int)
@dataclass
class UserRow:
id: str
username: str
display_name: str
password_hash: str
created_at: str
@dataclass
class ChatRow:
id: str
title: str
member_ids: list
created_dt: datetime
created_at: str
@dataclass
class MessageRow:
id: str
chat_id: str
sender_id: str
text: str
created_dt: datetime
created_at: str
@dataclass
class SessionRow:
token: str
user_id: str
expires_at: datetime
class MemoryStorage:
"""Хранилище в памяти из скелета lab1. В lab2 его заменяет PgStorage с теми же
сигнатурами методов, поэтому роутеры и зависимости менять не требуется."""
def __init__(self):
self._lock = threading.RLock()
self._users: dict[str, UserRow] = {}
self._by_username: dict[str, str] = {}
self._chats: dict[str, ChatRow] = {}
self._messages: dict[str, list[MessageRow]] = {}
self._sessions: dict[str, SessionRow] = {}
def ready(self) -> bool:
return True
# --- пользователи
def create_user(self, username: str, display_name: str, password_hash: str) -> UserRow:
with self._lock:
if username in self._by_username:
raise ApiError(409, 'Username is already taken')
row = UserRow(str(uuid.uuid4()), username, display_name, password_hash,
iso_z(now_utc()))
self._users[row.id] = row
self._by_username[username] = row.id
return row
def user_by_username(self, username: str) -> UserRow | None:
with self._lock:
uid = self._by_username.get(username)
return self._users.get(uid) if uid else None
def user(self, user_id: str) -> UserRow | None:
with self._lock:
return self._users.get(user_id)
# --- сессии
def create_session(self, user_id: str, ttl_seconds: int) -> SessionRow:
from app.core.security import new_token
with self._lock:
row = SessionRow(new_token(), user_id, now_utc() + timedelta(seconds=ttl_seconds))
self._sessions[row.token] = row
return row
def session(self, token: str) -> SessionRow | None:
with self._lock:
row = self._sessions.get(token)
if row is None:
return None
if now_utc() >= row.expires_at:
del self._sessions[token] # истёкшую сессию считаем отозванной
return None
return row
def revoke(self, token: str) -> bool:
with self._lock:
return self._sessions.pop(token, None) is not None
# --- чаты (создание атомарно под одной блокировкой)
def create_chat(self, title: str, member_ids: list, caller_id: str) -> ChatRow:
with self._lock:
if caller_id not in member_ids:
raise ApiError(400, 'Creator must be included in member_ids')
for mid in member_ids:
if mid not in self._users:
raise ApiError(400, 'Unknown member id')
moment = now_utc()
row = ChatRow(str(uuid.uuid4()), title, list(member_ids), moment, iso_z(moment))
self._chats[row.id] = row
self._messages[row.id] = []
return row
def chat(self, chat_id: str) -> ChatRow | None:
with self._lock:
return self._chats.get(chat_id)
def chats_of(self, user_id: str) -> list[ChatRow]:
with self._lock:
rows = [c for c in self._chats.values() if user_id in c.member_ids]
return sorted(rows, key=lambda c: order_key(c.created_dt, c.id))
# --- сообщения
def add_message(self, chat_id: str, sender_id: str, text: str) -> MessageRow:
with self._lock:
moment = now_utc()
row = MessageRow(str(uuid.uuid4()), chat_id, sender_id, text, moment, iso_z(moment))
self._messages[chat_id].append(row)
return row
def messages_of(self, chat_id: str) -> list[MessageRow]:
with self._lock:
rows = list(self._messages.get(chat_id, []))
return sorted(rows, key=lambda m: order_key(m.created_dt, m.id))
+210
View File
@@ -0,0 +1,210 @@
import uuid
import asyncpg
from app.core.errors import ApiError
from app.core.security import new_token
from app.repositories.memory import (
ChatRow, MessageRow, UserRow, iso_z,
)
def _user(row: asyncpg.Record | None) -> UserRow | None:
if row is None:
return None
return UserRow(
id=str(row['id']), username=row['username'], display_name=row['display_name'],
password_hash=row['password_hash'], created_at=iso_z(row['created_at']),
)
def _chat(row: asyncpg.Record) -> ChatRow:
moment = row['created_at']
return ChatRow(
id=str(row['id']), title=row['title'], member_ids=[str(x) for x in row['member_ids']],
created_dt=moment, created_at=iso_z(moment),
)
def _message(row: asyncpg.Record) -> MessageRow:
moment = row['created_at']
return MessageRow(
id=str(row['id']), chat_id=str(row['chat_id']), sender_id=str(row['sender_id']),
text=row['text'], created_dt=moment, created_at=iso_z(moment),
)
class PgStorage:
"""Хранилище пользователей, сессий, чатов, участников и сообщений на PostgreSQL."""
def __init__(self, pool: asyncpg.Pool, session_store):
self.pool = pool
self.session_store = session_store
async def ready(self) -> bool:
try:
async with self.pool.acquire() as connection:
database_ready = await connection.fetchval('SELECT 1') == 1
return database_ready and await self.session_store.ready()
except (asyncpg.PostgresError, OSError, TimeoutError):
return False
async def create_user(self, username: str, display_name: str, password_hash: str) -> UserRow:
try:
async with self.pool.acquire() as connection:
row = await connection.fetchrow(
'INSERT INTO users (id, username, display_name, password_hash) '
'VALUES ($1, $2, $3, $4) RETURNING *',
uuid.uuid4(), username, display_name, password_hash,
)
except asyncpg.UniqueViolationError as exc:
if exc.constraint_name == 'users_username_key':
raise ApiError(409, 'Username is already taken') from None
raise
return _user(row)
async def user_by_username(self, username: str) -> UserRow | None:
async with self.pool.acquire() as connection:
return _user(await connection.fetchrow(
'SELECT * FROM users WHERE username = $1', username
))
async def user(self, user_id: str) -> UserRow | None:
async with self.pool.acquire() as connection:
return _user(await connection.fetchrow(
'SELECT * FROM users WHERE id = $1', uuid.UUID(user_id)
))
async def create_session(self, user_id: str, ttl_seconds: int):
return await self.session_store.create_session(user_id, ttl_seconds)
async def session(self, token: str):
return await self.session_store.session(token)
async def revoke(self, token: str) -> bool:
return await self.session_store.revoke(token)
async def create_chat(self, title: str, member_ids: list[str], caller_id: str) -> ChatRow:
if caller_id not in member_ids:
raise ApiError(400, 'Creator must be included in member_ids')
chat_id = uuid.uuid4()
try:
async with self.pool.acquire() as connection:
async with connection.transaction():
created_at = await connection.fetchval(
'INSERT INTO chats (id, title) VALUES ($1, $2) RETURNING created_at',
chat_id, title,
)
await connection.executemany(
'INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)',
[(chat_id, uuid.UUID(member_id)) for member_id in member_ids],
)
except asyncpg.ForeignKeyViolationError:
raise ApiError(400, 'Unknown member id') from None
return ChatRow(
id=str(chat_id), title=title, member_ids=list(member_ids),
created_dt=created_at, created_at=iso_z(created_at),
)
async def chat(self, chat_id: str) -> ChatRow | None:
async with self.pool.acquire() as connection:
row = await connection.fetchrow(
'SELECT c.id, c.title, c.created_at, '
'array_agg(cm.user_id ORDER BY cm.user_id) AS member_ids '
'FROM chats c JOIN chat_members cm ON cm.chat_id = c.id '
'WHERE c.id = $1 GROUP BY c.id', uuid.UUID(chat_id),
)
return _chat(row) if row else None
async def chats_of(self, user_id: str) -> list[ChatRow]:
async with self.pool.acquire() as connection:
rows = await connection.fetch(
'SELECT c.id, c.title, c.created_at, '
'array_agg(cm_all.user_id ORDER BY cm_all.user_id) AS member_ids '
'FROM chats c '
'JOIN chat_members mine ON mine.chat_id = c.id '
'JOIN chat_members cm_all ON cm_all.chat_id = c.id '
'WHERE mine.user_id = $1 '
'GROUP BY c.id ORDER BY c.created_at, c.id', uuid.UUID(user_id),
)
return [_chat(row) for row in rows]
async def add_message(self, chat_id: str, sender_id: str, text: str) -> MessageRow:
async with self.pool.acquire() as connection:
row = await connection.fetchrow(
'INSERT INTO messages (id, chat_id, sender_id, text) '
'VALUES ($1, $2, $3, $4) RETURNING *',
uuid.uuid4(), uuid.UUID(chat_id), uuid.UUID(sender_id), text,
)
return _message(row)
async def add_idempotent_message(
self, chat_id: str, sender_id: str, text: str,
idempotency_key: str, request_hash: bytes,
) -> MessageRow:
"""Создать сообщение и запись повтора одной транзакцией для всех API-реплик."""
chat_uuid = uuid.UUID(chat_id)
sender_uuid = uuid.UUID(sender_id)
lock_scope = f'{sender_uuid}:POST:/api/v1/chats/{chat_uuid}/messages:{idempotency_key}'
async with self.pool.acquire() as connection:
async with connection.transaction():
# Advisory lock общий для всех API и сериализует запросы с одинаковым ключом.
await connection.fetchval(
'SELECT pg_advisory_xact_lock(hashtextextended($1, 0))', lock_scope,
)
existing = await connection.fetchrow(
'SELECT k.request_hash, m.* FROM message_idempotency k '
'JOIN messages m ON m.id = k.message_id '
'WHERE k.user_id = $1 AND k.chat_id = $2 AND k.idempotency_key = $3 '
"AND k.created_at > now() - interval '24 hours'",
sender_uuid, chat_uuid, idempotency_key,
)
if existing is not None:
if bytes(existing['request_hash']) != request_hash:
raise ApiError(409, 'Idempotency-Key was already used with another request')
return _message(existing)
# После 24 часов ключ можно использовать снова; удаляем старые записи партиями.
await connection.execute(
'DELETE FROM message_idempotency '
'WHERE user_id = $1 AND chat_id = $2 AND idempotency_key = $3',
sender_uuid, chat_uuid, idempotency_key,
)
await connection.execute(
"DELETE FROM message_idempotency WHERE ctid IN ("
'SELECT ctid FROM message_idempotency '
"WHERE created_at <= now() - interval '24 hours' "
'ORDER BY created_at LIMIT 100)'
)
row = await connection.fetchrow(
'INSERT INTO messages (id, chat_id, sender_id, text) '
'VALUES ($1, $2, $3, $4) RETURNING *',
uuid.uuid4(), chat_uuid, sender_uuid, text,
)
await connection.execute(
'INSERT INTO message_idempotency '
'(user_id, chat_id, idempotency_key, request_hash, message_id) '
'VALUES ($1, $2, $3, $4, $5)',
sender_uuid, chat_uuid, idempotency_key, request_hash, row['id'],
)
return _message(row)
async def messages_page(self, chat_id: str, cursor_key, limit: int):
"""Прочитать одну отсортированную keyset-страницу и одну строку для проверки продолжения."""
chat_uuid = uuid.UUID(chat_id)
async with self.pool.acquire() as connection:
if cursor_key is None:
rows = await connection.fetch(
'SELECT * FROM messages WHERE chat_id = $1 '
'ORDER BY created_at, id LIMIT $2', chat_uuid, limit + 1,
)
else:
created_at, id_value = cursor_key
rows = await connection.fetch(
'SELECT * FROM messages WHERE chat_id = $1 '
'AND (created_at, id) > ($2, $3) '
'ORDER BY created_at, id LIMIT $4',
chat_uuid, created_at, uuid.UUID(int=id_value), limit + 1,
)
has_more = len(rows) > limit
return [_message(row) for row in rows[:limit]], has_more
+66
View File
@@ -0,0 +1,66 @@
import hashlib
import time
from datetime import datetime, timedelta, timezone
from redis.asyncio import Redis
from redis.exceptions import RedisError
from app.core.errors import ApiError
from app.core.security import new_token
from app.repositories.memory import SessionRow, now_utc
class RedisSessionStore:
"""Redis — источник истины для сессий; PXAT сохраняет исходный срок истечения после перезапуска."""
def __init__(self, client: Redis):
self.client = client
@staticmethod
def _key(token: str) -> str:
digest = hashlib.sha256(token.encode('utf-8')).hexdigest()
return 'session:' + digest
async def ready(self) -> bool:
try:
return bool(await self.client.ping())
except (RedisError, OSError, TimeoutError):
return False
async def create_session(self, user_id: str, ttl_seconds: int) -> SessionRow:
token = new_token()
current = now_utc()
expires_at = current.replace(microsecond=(current.microsecond // 1000) * 1000) + timedelta(seconds=ttl_seconds)
expires_ms = int(expires_at.timestamp() * 1000)
try:
await self.client.set(
self._key(token), f'{user_id}|{expires_ms}', pxat=expires_ms
)
except RedisError:
raise ApiError(503, 'Session storage is unavailable') from None
return SessionRow(token=token, user_id=user_id, expires_at=expires_at)
async def session(self, token: str) -> SessionRow | None:
try:
value = await self.client.get(self._key(token))
except RedisError:
raise ApiError(503, 'Session storage is unavailable') from None
if value is None:
return None
try:
user_id, expires_ms_text = value.split('|', 1)
expires_ms = int(expires_ms_text)
if expires_ms <= int(time.time() * 1000):
await self.client.delete(self._key(token))
return None
expires_at = datetime.fromtimestamp(expires_ms / 1000, timezone.utc)
return SessionRow(token=token, user_id=user_id, expires_at=expires_at)
except (ValueError, OverflowError):
await self.client.delete(self._key(token))
return None
async def revoke(self, token: str) -> bool:
try:
return bool(await self.client.delete(self._key(token)))
except RedisError:
raise ApiError(503, 'Session storage is unavailable') from None
+68
View File
@@ -0,0 +1,68 @@
import uuid as _uuid
from typing import Literal
from pydantic import BaseModel, ConfigDict, Field, field_validator
STRICT = ConfigDict(extra='forbid')
class CreateUser(BaseModel):
model_config = STRICT
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)
@field_validator('display_name', 'password')
@classmethod
def _not_blank(cls, value: str) -> str:
if not value.strip():
raise ValueError('string must not consist of whitespace only')
return value
class User(BaseModel):
model_config = STRICT
id: _uuid.UUID
username: str
display_name: str
created_at: str
class Session(BaseModel):
model_config = STRICT
token: str
token_type: Literal['Bearer']
expires_at: str
user: User
class CreateChat(BaseModel):
model_config = STRICT
title: str = Field(min_length=1, max_length=100)
member_ids: list[_uuid.UUID] = Field(min_length=1, max_length=100)
@field_validator('title')
@classmethod
def _title_not_blank(cls, value: str) -> str:
if not value.strip():
raise ValueError('string must not consist of whitespace only')
return value
@field_validator('member_ids')
@classmethod
def _unique_members(cls, value):
if len(set(value)) != len(value):
raise ValueError('duplicate member ids')
return value
class CreateMessage(BaseModel):
model_config = STRICT
text: str = Field(min_length=1, max_length=4000)
@field_validator('text')
@classmethod
def _text_not_blank(cls, value: str) -> str:
if not value.strip():
raise ValueError('string must not consist of whitespace only')
return value
+104
View File
@@ -0,0 +1,104 @@
name: mtusi-lab3
services:
postgres:
image: postgres:16.4-alpine
environment:
POSTGRES_USER: ${POSTGRES_USER:?Set POSTGRES_USER in .env}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
POSTGRES_DB: ${POSTGRES_DB:?Set POSTGRES_DB in .env}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U \"$${POSTGRES_USER}\" -d \"$${POSTGRES_DB}\""]
interval: 3s
timeout: 3s
retries: 30
start_period: 5s
restart: unless-stopped
redis:
image: redis:7.4.2-alpine
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always", "--save", ""]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 3s
timeout: 3s
retries: 30
start_period: 5s
restart: unless-stopped
migrate:
build:
context: .
dockerfile: Dockerfile
command: ["python", "-m", "app.db.migrate"]
environment:
DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
DB_POOL_MIN_SIZE: 1
DB_POOL_MAX_SIZE: 2
DB_POOL_ACQUIRE_TIMEOUT_SECONDS: 3
DB_COMMAND_TIMEOUT_SECONDS: 10
depends_on:
postgres:
condition: service_healthy
restart: "no"
api:
build:
context: .
dockerfile: Dockerfile
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
DB_POOL_MIN_SIZE: ${DB_POOL_MIN_SIZE:-1}
DB_POOL_MAX_SIZE: ${DB_POOL_MAX_SIZE:-8}
DB_POOL_ACQUIRE_TIMEOUT_SECONDS: ${DB_POOL_ACQUIRE_TIMEOUT_SECONDS:-3}
DB_COMMAND_TIMEOUT_SECONDS: ${DB_COMMAND_TIMEOUT_SECONDS:-5}
REDIS_URL: redis://redis:6379/0
REDIS_TIMEOUT_SECONDS: ${REDIS_TIMEOUT_SECONDS:-2}
depends_on:
migrate:
condition: service_completed_successfully
postgres:
condition: service_healthy
redis:
condition: service_healthy
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"]
interval: 3s
timeout: 3s
retries: 10
start_period: 8s
deploy:
replicas: ${API_REPLICAS:-2}
resources:
limits:
cpus: "1.0"
memory: 512M
stop_grace_period: 20s
restart: unless-stopped
lb:
image: nginx:1.27.4-alpine
ports:
- "127.0.0.1:${LB_PORT:-8081}:8080"
volumes:
- ./nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
depends_on:
api:
condition: service_healthy
healthcheck:
test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1:8080/health/ready"]
interval: 3s
timeout: 3s
retries: 10
restart: unless-stopped
volumes:
postgres_data:
redis_data:
+3
View File
@@ -0,0 +1,3 @@
Command: docker compose --env-file .env config --quiet
Exit code: 0
Stdout: (empty)
+4
View File
@@ -0,0 +1,4 @@
Command: docker compose --env-file .env up -d --build --scale api=2; docker compose --env-file .env ps
Result: API image built; the one-shot migration job exited 0; postgres, redis, api-1, api-2 and lb became healthy.
LB bound to 127.0.0.1:8081. API, PostgreSQL and Redis host ports are not published.
Images: python:3.12.8-slim, postgres:16.4-alpine, redis:7.4.2-alpine, nginx:1.27.4-alpine.
+5
View File
@@ -0,0 +1,5 @@
Date: 2026-10-27
Command: make check (Ubuntu WSL)
Output:
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+5
View File
@@ -0,0 +1,5 @@
Date: 2026-10-27
Command: make test-idempotency BASE_URL=http://127.0.0.1:8081 (Ubuntu WSL)
Output:
python3 tests/idempotency.py --base-url "http://127.0.0.1:8081"
PASS: 16 concurrent requests across 2 API replicas returned one Message; changed body returned 409.
+5
View File
@@ -0,0 +1,5 @@
Date: 2026-10-27
Command: make test BASE_URL=http://127.0.0.1:8081 (Ubuntu WSL; port 8081 is the local override while Lab 2 is already running on 8080)
Output:
python3 tests/smoke.py --base-url "http://127.0.0.1:8081"
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
+5
View File
@@ -0,0 +1,5 @@
Date: 2026-10-27
Command: make validate PYTHON=/home/lenovo/lab2/.venv/bin/python (Ubuntu WSL)
Output:
/home/lenovo/lab2/.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
+6
View File
@@ -0,0 +1,6 @@
Commands: docker compose --env-file .env run --rm migrate (twice); query schema_migrations
Output versions:
1
2
3
Both reruns exited 0; migration version rows were not duplicated.
+3
View File
@@ -0,0 +1,3 @@
Commands: sh -n scripts/restart.sh; sh -n scripts/stop-one.sh
Output:
PASS: POSIX hook syntax
+9
View File
@@ -0,0 +1,9 @@
Date: 2026-10-27
Code under test before squash: a74e32e
Command: make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://127.0.0.1:8081 (Ubuntu WSL; tracked POSIX hook)
Output:
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://127.0.0.1:8081"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 140, "failed_attempts": 0, "first_recovery_seconds": 0.673}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
The test stopped the selected API container; the stopped replica was restored after the check.
+8
View File
@@ -0,0 +1,8 @@
Date: 2026-10-27
Code under test before squash: a74e32e
Command: make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8081 (Ubuntu WSL; tracked POSIX hook)
Output:
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://127.0.0.1:8081"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
The hook restarted PostgreSQL, Redis, both API replicas and Nginx. Named volumes were retained.
+6
View File
@@ -0,0 +1,6 @@
Дата и время: 2026-10-27, Europe/Moscow
Ревизия исходников под проверкой до squash: a74e32e; содержимое исходников и Compose при squash не менялось.
Docker Desktop Linux: 32 vCPU; 16 598 642 688 bytes RAM доступно Docker.
Лимит API: 1 CPU и 536 870 912 bytes памяти на реплику; запущено две реплики.
Профили: публичный smoke на синтетических данных; идемпотентность — 16 одновременных запросов с одним ключом; persistence — restart API/PostgreSQL/Redis/LB с сохранёнными volumes; failover — 15-секундный поток POST, 140 успешных ответов, 0 переходных ошибок, первая успешная запись через 0.673 секунды.
Failover — проверка критерия уровня 3, не нагрузочный benchmark; throughput и p95/p99 не заявляются.
+37
View File
@@ -0,0 +1,37 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL CHECK (length(display_name) BETWEEN 1 AND 100),
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL CHECK (length(title) BETWEEN 1 AND 100 AND btrim(title) <> ''),
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_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 CHECK (length(text) BETWEEN 1 AND 4000 AND btrim(text) <> ''),
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
-- A leaked session table must not contain usable bearer credentials.
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at timestamptz NOT NULL
);
CREATE INDEX sessions_expiry_idx ON sessions (expires_at);
@@ -0,0 +1,3 @@
-- Active sessions move to Redis in lab2 grade 4; old token digests cannot be
-- reconstructed and are intentionally invalidated during this one-time migration.
DROP TABLE IF EXISTS sessions;
+10
View File
@@ -0,0 +1,10 @@
CREATE TABLE message_idempotency (
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
idempotency_key text NOT NULL CHECK (idempotency_key ~ '^[A-Za-z0-9._:-]{1,128}$'),
request_hash bytea NOT NULL CHECK (octet_length(request_hash) = 32),
message_id uuid NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (user_id, chat_id, idempotency_key)
);
CREATE INDEX message_idempotency_expiry_idx ON message_idempotency (created_at);
+28
View File
@@ -0,0 +1,28 @@
# Containers in Compose are resolved through Docker's embedded DNS. The `resolve`
# parameter refreshes the API addresses as replicas are replaced or stopped.
resolver 127.0.0.11 valid=1s ipv6=off;
upstream api_backend {
zone api_backend 64k;
server api:8080 resolve max_fails=1 fail_timeout=2s;
keepalive 32;
}
server {
listen 8080;
server_name _;
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 10s;
proxy_read_timeout 10s;
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 2;
}
}
+6
View File
@@ -0,0 +1,6 @@
fastapi==0.115.6
uvicorn==0.34.0
pydantic-settings==2.7.1
argon2-cffi==23.1.0
asyncpg==0.30.0
redis==5.2.1
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
# Restart API, entrypoint and shared stores without removing named volumes.
docker compose restart postgres redis api lb
+15
View File
@@ -0,0 +1,15 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
: "${TARGET_INSTANCE_ID:?test provides X-Instance-Id of the target replica}"
for container in $(docker compose ps -q api); do
instance_id=$(docker inspect --format '{{.Config.Hostname}}' "$container")
if [ "$instance_id" = "$TARGET_INSTANCE_ID" ]; then
# Manual stop leaves this replica out of service until the operator restores it.
docker stop --timeout 1 "$container" >/dev/null
exit 0
fi
done
printf '%s\n' 'target API replica was not found; no container was stopped' >&2
exit 1
+49
View File
@@ -0,0 +1,49 @@
#!/usr/bin/env python3
"""Проверка атомарного повтора одного сообщения через разные API-реплики."""
from concurrent.futures import ThreadPoolExecutor
import uuid
from client import Client, arguments, check, run
def main():
args = arguments('Concurrent cross-replica idempotency check')
setup = Client(args.base_url, args.ca_file)
alice, _bob, _eve, chat = setup.bootstrap()
key = 'concurrent-' + uuid.uuid4().hex
text = 'Одно сообщение при конкурентном повторе ' + uuid.uuid4().hex
count = 16
def send(_):
client = Client(args.base_url, args.ca_file, timeout=10)
return client.call(
'POST', '/api/v1/chats/' + chat['id'] + '/messages', expected=201,
actor=alice, body={'text': text}, headers={'Idempotency-Key': key}, schema='Message',
)
with ThreadPoolExecutor(max_workers=count) as pool:
responses = list(pool.map(send, range(count)))
messages = [response['json'] for response in responses]
instance_ids = {response['headers'].get('X-Instance-Id') for response in responses}
check(all(message == messages[0] for message in messages), 'concurrent replay returned different Message objects')
check(len(instance_ids) >= 2, 'concurrent requests did not reach at least two observable API replicas')
replay = setup.call(
'POST', '/api/v1/chats/' + chat['id'] + '/messages', expected=201,
actor=alice, body={'text': text}, headers={'Idempotency-Key': key}, schema='Message',
)['json']
check(replay == messages[0], 'retry returned a different status payload')
setup.call(
'POST', '/api/v1/chats/' + chat['id'] + '/messages', expected=409,
actor=alice, body={'text': text + ' другой текст'}, headers={'Idempotency-Key': key},
)
history = setup.call(
'GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=100',
actor=alice, schema='MessagePage',
)['json']['items']
matching = [message for message in history if message['text'] == text]
check(matching == [messages[0]], 'history contains a missing or duplicate side effect')
print('PASS: %d concurrent requests across %d API replicas returned one Message; changed body returned 409.' % (count, len(instance_ids)))
if __name__ == '__main__':
run(main)