ЛР2-БПИ2304-Кондрашов Никита - на 5 #181

Closed
makkelay wants to merge 2 commits from makkelay/mtusi2026lab2:solution/bpi2304-nikko into master
21 changed files with 1579 additions and 25 deletions
+4 -5
View File
@@ -4,8 +4,7 @@ APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
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
DB_POOL_MAX_SIZE=10
# Create this ignored file locally; Docker Compose mounts it as a secret.
# PostgreSQL is the source of truth for sessions and durable application data.
# Redis stores a TTL-bound profile cache; PostgreSQL validates revocation/expiry.
+15
View File
@@ -0,0 +1,15 @@
FROM python:3.12.8-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1
WORKDIR /srv/messenger
COPY requirements.txt .
RUN python -m pip install --no-cache-dir -r requirements.txt
COPY app ./app
USER 10001:10001
EXPOSE 8080
CMD ["sh", "-c", "python -m app.migrate && exec uvicorn app.main:app --host 0.0.0.0 --port 8080 --workers 1"]
+18 -2
View File
@@ -4,10 +4,11 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
.PHONY: help check validate test load test-persistence test-grade4 test-expiry test-rollback test-track5-cache explain-history
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "check: offline structure; validate: full OpenAPI; test: running API; test-grade4: concurrency and dependency outages; test-track5-cache: Redis single-flight"
@echo "test-expiry: run against SESSION_TTL_SECONDS=2; explain-history: EXPLAIN a rollback-only 10k-message fixture"
check:
$(PYTHON) scripts/check_contract.py
@@ -24,3 +25,18 @@ load:
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-grade4:
$(PYTHON) tests/grade4.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-expiry:
$(PYTHON) tests/expiry.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-rollback:
$(PYTHON) tests/transaction_rollback.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-track5-cache:
$(PYTHON) tests/cache_singleflight.py --base-url "$(BASE_URL)" $(TLS_ARGS)
explain-history:
docker compose exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 < scripts/benchmark_history.sql
+75 -2
View File
@@ -2,7 +2,7 @@
Перенести состояние в постоянное хранилище и связать запросы с аутентифицированным пользователем. Подтверждённые сообщения и действующие сессии переживают перезапуск.
Это **skeleton**, а не готовый сервер. Здесь есть задание, контракт и публичные проверки. Реализацию приложения, Dockerfile и требуемую инфраструктуру пишет студент. Язык и framework свободные; UI не обязателен.
Этот форк содержит рабочую реализацию задания: API, миграции PostgreSQL, Compose-стенд и проверки. UI не обязателен.
[Карта курса](COURSE.md) · [Процесс fork/PR](CONTRIBUTING.md) · [OpenAPI](contracts/openapi.json) · [Семантика API](contracts/README.md) · [Проверки](tests/README.md) · [Отчёт](REPORT.md) · [Примеры JSON](contracts/examples.json) · [Памятка преподавателю](MAINTAINERS.md)
@@ -12,6 +12,23 @@
**Архитектура:** Клиент → API → PostgreSQL; на 4 появляется Redis ИЛИ Valkey для сессий/кэша.
Перенесён минимум lab1: регистрация и чтение профиля, создание/чтение чатов, сообщения и keyset-пагинация. Контракт аутентификации изменён: регистрация принимает password, Basic используется только для `POST /api/v1/auth/sessions`, бизнес-запросы используют Bearer-сессию. `X-User-Id` игнорируется и сам по себе доступ не даёт.
## Модель данных и транзакционные границы
Миграция `app/migrations/001_initial.sql` создаёт схему с нуля; `app/migrate.py` применяет каждую версию один раз в общей транзакции и записывает её в `schema_migrations`.
| Таблица | Ключи и ограничения | Индексы и назначение |
| --- | --- | --- |
| `users` | PK `id`; UNIQUE `username`; CHECK формата username и непустого display name; хранится только Argon2id hash пароля | Уникальный индекс username создаётся ограничением |
| `chats` | PK `id`; CHECK непустого title | PK для адресации чата |
| `chat_members` | Составной PK `(chat_id, user_id)`; FK на `chats` с CASCADE и на `users` с RESTRICT | `(user_id, chat_id)` для списка чатов участника |
| `messages` | PK `id`; FK чата с CASCADE и отправителя с RESTRICT; CHECK непустого текста | `(chat_id, created_at, id)` обслуживает фильтрацию и keyset-страницы истории |
| `sessions` | PK `token_hash`; FK на пользователя с CASCADE; обязательный `expires_at`, nullable `revoked_at`; исходный Bearer-токен не хранится | Частичный индекс `expires_at` по неотозванным сессиям |
| `schema_migrations` | PK `version` | Уникально фиксирует применённые миграции |
Регистрация выполняет один INSERT. Создание чата проверяет участников, добавляет чат и все строки членства внутри одной транзакции: ошибка любого INSERT откатывает всю операцию. Создание и отзыв сессии также фиксируются в PostgreSQL транзакцией; logout сначала сохраняет отзыв, затем удаляет кэш. Сообщение записывается одним INSERT. История выбирает `limit + 1` строку по `(created_at, id)` без OFFSET.
## Что сделать
1. Опишите таблицы, ограничения, индексы и транзакционные границы до написания запросов. Добавьте версионируемые миграции.
@@ -55,6 +72,14 @@ make check
make test
```
Для трека 1 после запуска Compose-стенда выполните проверку Redis single-flight:
```sh
make test-track5-cache BASE_URL=http://localhost:8080
```
Проверка создаёт пользователя/сессию, очищает профиль из Redis, отправляет 16 параллельных запросов и по событиям `profile_cache_fill` с уникальными request ID считает фактические SQL-запросы загрузки профиля. Затем сравнивает холодный и прогретый кэш по p95 latency, перезапускает Redis, удаляет только тестовый ключ и проверяет повторную загрузку профиля из PostgreSQL. Без single-flight конкурентный cache miss мог бы вызвать до 16 запросов профиля; проверка требует ровно одного. PostgreSQL всё равно проверяет expiry/revocation каждой сессии. Тест перезапускает Redis и требует Docker Compose CLI.
`.env.example`, `compose.example.yaml` и `contracts/infrastructure.json` описывают настройки и роли компонентов. **compose.example.yaml — список ролей с пустым services, не запускаемый стенд.** Реализуйте свой `compose.yaml`/`stack.yaml`, закрепите версии образов, заполните локальный `.env` и опишите bootstrap/миграции. Все зависимости поднимаются из этого репозитория; ссылка «у меня БД уже установлена» не заменяет воспроизводимость.
```sh
@@ -62,9 +87,57 @@ make test
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
# Дождитесь /health/ready; затем make test.
# Для Swarm укажите эквивалентные build/push/deploy-команды в REPORT.md.
# Локальный стенд уровня 3/4 (Docker Compose)
Стек: FastAPI/Python, PostgreSQL как источник истины, Redis для TTL-кэша профиля действующей сессии. Пароли хешируются Argon2id. Внутренние таблицы состояния из lab1 заменены реляционной схемой; клиентские операции минимума lab1 сохранены с объявленным переходом на новую аутентификацию.
Требуются Docker Compose v2 и OpenSSL. Создайте игнорируемый локальный secret и запустите стенд:
```sh
umask 077
mkdir -p secrets
openssl rand -hex 32 > secrets/database_password
chmod 600 secrets/database_password
docker compose config --quiet
docker compose up -d --build
```
Compose запускает миграции перед API, публикует только порт API и сохраняет состояние PostgreSQL/Redis в именованных volumes. Секрет БД монтируется как Compose secret; `.env`, secrets и volumes не коммитятся. Убедитесь в готовности и выполните публичный сценарий:
Если при старте миграции сообщает, что не задан `DB_PASSWORD`, контейнер, вероятно, запущен отдельно от Compose или без смонтированного secret. Используйте команды выше из корня проекта после создания `secrets/database_password`; после изменения исходников пересоберите образ. Для отдельного `docker run` нужно передать `DB_PASSWORD_FILE=/run/secrets/database_password` и смонтировать файл secret именно по этому пути. Предпочтительный способ запуска — Compose.
```sh
curl --fail http://localhost:8080/health/ready
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
```
Миграции версионированы и пропускают уже применённую версию. Без удаления volumes стенд останавливается командой `docker compose down`; для намеренного удаления учебных данных используйте `docker compose down -v` только после того, как сохранность данных больше не нужна.
## Автоматические проверки уровня 4
```sh
make test-grade4
make test-rollback
make explain-history
```
`test-grade4` конкурентно регистрирует одинаковый username, проверяет неверный пароль и logout, останавливает Redis (сессия должна продолжить работать через PostgreSQL), затем PostgreSQL (ready и защищённый запрос должны получить 503), после чего запускает PostgreSQL обратно. Команда временно останавливает сервисы Compose и предназначена только для локального тестового стенда.
`test-rollback` временно ставит тестовый триггер PostgreSQL, который заставляет вставку участника чата завершиться ошибкой после вставки строки чата; проверяет 503 и отсутствие частичного чата, затем удаляет триггер. Запускайте только на этом учебном экземпляре.
`explain-history` в транзакции создаёт 10 000 синтетических сообщений, запускает `EXPLAIN (ANALYZE, BUFFERS)` для keyset-страницы и откатывает fixture. Индекс `messages_history_keyset(chat_id, created_at, id)` соответствует фильтру чата и сортировке `(created_at, id)`. Сохраните вывод плана в доказательствах после выполнения: он не предзаполнен в репозитории и не подменён ожидаемым результатом.
Проверка короткого срока сессии выполняется на отдельном запуске API:
```sh
SESSION_TTL_SECONDS=2 docker compose up -d --force-recreate api
make test-expiry
# Верните обычный TTL и пересоздайте API после проверки:
SESSION_TTL_SECONDS=3600 docker compose up -d --force-recreate api
```
Сессии хранятся в PostgreSQL вместе с абсолютным `expires_at`; Redis хранит только профиль с TTL не дольше срока сессии. Любая авторизация проверяет в PostgreSQL expiry/revocation, поэтому Redis cache miss/failure безопасно обходит кэш, а недоступность БД возвращает 503. Logout сначала фиксирует отзыв в PostgreSQL, а кэш инвалидируется best-effort; запрос не может быть принят только на основании кэшированной записи.
Примеры запросов доступны в `examples/requests.http`, примеры JSON — в `contracts/examples.json`. Для полной проверки схемы (по желанию локально; CI делает её автоматически):
+24 -13
View File
@@ -1,37 +1,48 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: заполнить перед сдачей
- Целевая оценка; выбранный трек 5, если нужен: 4; трек 5 не заявлен
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные библиотеки: FastAPI, psycopg 3 connection pool, redis-py, argon2-cffi/Argon2id.
- Перенесён минимум lab1: регистрация пользователя, профиль `/users/me`, создание/список/чтение чатов, сообщения и keyset-пагинация. API-изменение объявлено: password при регистрации, Basic только на создание сессии, Bearer на все защищённые операции; `X-User-Id` не является способом аутентификации.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Prerequisites, выпуск локального secret, запуск, проверки, безопасная остановка и осознанное удаление volumes документированы в README.md. Образы закреплены тегами в compose.yaml, приложение строится из Dockerfile. Перед сдачей запишите проверенные версии Docker/Compose и Python, а также фактические команды и результаты запуска.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
API (FastAPI) обслуживает синхронные HTTP-запросы; PostgreSQL хранит пользователей, чаты, участников, сообщения и сессии; Redis хранит кэш профиля сессии. PostgreSQL — источник истины данных и состояния сессии. На каждом Bearer-запросе expiry/revocation сверяются с PostgreSQL; при cache miss Redis заполняется профилем из БД, при отказе Redis профиль читается из БД. Redis TTL не длиннее `expires_at`; logout фиксирует отзыв в БД и затем удаляет кэш. Недоступность Redis не ослабляет аутентификацию, недоступность PostgreSQL приводит к ограниченному 503.
До реализации запросов зафиксирована схема и границы транзакций в README. Миграция `001_initial.sql` определяет PK/FK/CHECK/UNIQUE и индексы `chat_members_by_user`, `messages_history_keyset` и `sessions_active_by_expiry`. `app/migrate.py` применяет версионированные миграции транзакционно и пропускает уже применённую версию. Создание чата и всех строк `chat_members` выполняется в одной транзакции; ошибка любой вставки откатывает операцию. История читает `limit + 1` запись по keyset `(created_at, id)`, без OFFSET и полного сканирования истории на каждой странице.
Пул ограничен `DB_POOL_MAX_SIZE` (по умолчанию 10; допустимо 1–50), checkout timeout 2 секунды, connect timeout 3 секунды, statement timeout 5 секунд и lock timeout 3 секунды. Пароли Argon2id; сессионный bearer — 256-битное случайное значение, в БД хранится только SHA-256 token fingerprint. Переносится функциональный минимум API lab1, а не его in-memory формат хранения.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | `make test` | PASS на Compose, API + PostgreSQL 16.6 + Redis | [local-validation.txt](./evidence/local-validation.txt) |
| Полный перезапуск с volume | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS: после рестарта API, PostgreSQL и Redis прежний Bearer-токен читает сохранённые данные | [local-validation.txt](./evidence/local-validation.txt) |
| Регистрация и негативные проверки | `make test-grade4` | PASS на Compose: гонка username, неверный пароль, logout, Redis fallback, 503 при остановке PostgreSQL и восстановление | [local-validation.txt](./evidence/local-validation.txt) |
| Rollback создания чата | `make test-rollback` | PASS на Compose PostgreSQL с инъекцией ошибки при вставке второго участника; чат и первая membership-запись откатились | [local-validation.txt](./evidence/local-validation.txt) |
| TTL и expiry | `SESSION_TTL_SECONDS=2 docker compose up -d --force-recreate api; make test-expiry` | PASS на Compose: после expiry прежний token получает 401; после теста восстановлен TTL 3600 | [local-validation.txt](./evidence/local-validation.txt) |
| План индекса на 10 000 сообщениях | `make explain-history` | PASS на Compose PostgreSQL 16.6: `Index Scan using messages_history_keyset`, 51 rows actual, 3 shared buffer hits | [local-validation.txt](./evidence/local-validation.txt) |
| Все пункты уровня 4 | Команды выше | Проверены на локальном Compose-стенде с PostgreSQL и Redis; результаты и границы эксперимента приведены ниже. | [local-validation.txt](./evidence/local-validation.txt) |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Результаты относятся к локальному учебному Compose-стенду и синтетическим данным.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Повторная проверка 2026-11-10 выполнена на отдельном Compose-проекте с чистыми именованными volumes, PostgreSQL 16.6 и Redis 7.4.2. `make check`, `make validate`, `make test`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh`, `make test-grade4`, `make test-rollback`, `make test-expiry` с `SESSION_TTL_SECONDS=2` и `make explain-history` прошли. Этот прогон заменяет предыдущие статусы отказа в таблице ниже. После expiry восстановлен TTL 3600; повторный smoke прошёл. Миграция `001_initial.sql` записана один раз. `EXPLAIN (ANALYZE, BUFFERS)` для 10 000 сообщений выбрал `messages_history_keyset`: 51 строка, 3 shared buffer hits, 0.034 ms execution. В проверке rollback тестовый триггер после проверки удалён.
Гипотеза для плана: индекс `(chat_id, created_at, id)` поддержит фильтрацию по чату и keyset-сортировку без полного прохода истории. 2026-11-09 эксперимент выполнен на Compose PostgreSQL 16.6, 10 000 синтетических строк внутри транзакции; после `ANALYZE` план выбрал `Index Scan using messages_history_keyset`, 51 строка прочитана за 0.031 ms, `Buffers: shared hit=3`, планирование — 0.130 ms. Fixture после `ROLLBACK` не сохранялся. Это один прогретый запуск и не оценка latency под нагрузкой. Дополнительный локальный PostgreSQL 16.11 результат от 2026-10-30 сохранён в evidence.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Остановка Redis | Bearer запрос продолжит работать через PostgreSQL | Не проверено с реальным Redis; локальная интеграция использовала test double | [local-validation.txt](./evidence/local-validation.txt) |
| Остановка PostgreSQL | ready и защищённый запрос вернут 503; анонимный доступ не появляется | Не проверено: Docker API перестал отвечать в ходе валидации | [local-validation.txt](./evidence/local-validation.txt) |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Стенд single-node и не гарантирует HA при потере Docker host или volume. Redis — кэш, поэтому кэшированные профили можно восстановить из PostgreSQL; AOF настроен для сохранности Redis volume, но его потеря не должна терять сессии. Вложения, API нескольких реплик и треки уровня 5 не реализованы.
View File
+732
View File
@@ -0,0 +1,732 @@
import base64
import binascii
import hashlib
import json
import logging
import os
import re
import secrets
import time
import uuid
from contextlib import asynccontextmanager
from datetime import datetime, timedelta, timezone
from typing import Any, Dict, List, Optional, Tuple
import psycopg
import redis
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError
from fastapi import Depends, FastAPI, Header, Request, Response
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from pydantic import BaseModel, ConfigDict, Field, field_validator
from psycopg.errors import UniqueViolation
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool, PoolTimeout
from starlette.exceptions import HTTPException as StarletteHTTPException
from app.settings import database_connection, session_ttl_seconds
logging.basicConfig(level=os.environ.get("LOG_LEVEL", "INFO"))
logger = logging.getLogger("messenger")
PASSWORD_HASHER = PasswordHasher()
USERNAME_PATTERN = re.compile(r"^[a-z0-9_]{3,32}$")
CURSOR_VERSION = 1
MAX_POOL_SIZE = int(os.environ.get("DB_POOL_MAX_SIZE", "10"))
if MAX_POOL_SIZE < 1 or MAX_POOL_SIZE > 50:
raise RuntimeError("DB_POOL_MAX_SIZE must be between 1 and 50")
class APIError(Exception):
def __init__(
self, status_code: int, code: str, message: str, challenge: Optional[str] = None
) -> None:
self.status_code = status_code
self.code = code
self.message = message
self.challenge = challenge
class StrictModel(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
class UserInput(StrictModel):
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")
@classmethod
def display_name_not_blank(cls, value: str) -> str:
if not value.strip():
raise ValueError("display_name must not be blank")
return value
@field_validator("password")
@classmethod
def password_no_nul(cls, value: str) -> str:
if "\x00" in value:
raise ValueError("password contains an invalid character")
return value
class ChatInput(StrictModel):
title: str = Field(min_length=1, max_length=100)
member_ids: List[str] = 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("title must not be blank")
return value
class MessageInput(StrictModel):
text: str = Field(min_length=1, max_length=4000)
def utc_string(value: datetime) -> str:
return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace(
"+00:00", "Z"
)
def user_json(row: Dict[str, Any]) -> Dict[str, str]:
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": utc_string(row["created_at"]),
}
def chat_json(row: Dict[str, Any], member_ids: List[str]) -> Dict[str, Any]:
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": member_ids,
"created_at": utc_string(row["created_at"]),
}
def message_json(row: Dict[str, Any]) -> Dict[str, str]:
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": utc_string(row["created_at"]),
}
def db_unavailable() -> APIError:
return APIError(503, "unavailable", "Сервис временно недоступен")
def get_connection():
pool: ConnectionPool = app.state.pool
try:
with pool.connection(timeout=2) as connection:
yield connection
except (psycopg.OperationalError, PoolTimeout) as exc:
logger.warning("database connection unavailable: %s", type(exc).__name__)
raise db_unavailable() from None
@asynccontextmanager
async def lifespan(application: FastAPI):
session_ttl_seconds()
application.state.pool = ConnectionPool(
conninfo="",
kwargs={
**database_connection(),
"autocommit": True,
"row_factory": dict_row,
},
min_size=1,
max_size=MAX_POOL_SIZE,
timeout=2,
max_lifetime=1800,
open=True,
name="messenger-api",
)
redis_url = os.environ.get("REDIS_URL", "redis://localhost:6379/0")
application.state.redis = redis.Redis.from_url(
redis_url,
socket_connect_timeout=1,
socket_timeout=1,
decode_responses=True,
health_check_interval=30,
)
application.state.instance_id = str(uuid.uuid4())
try:
yield
finally:
application.state.redis.close()
application.state.pool.close()
app = FastAPI(title="Messenger API", version="1.0.0", lifespan=lifespan)
@app.middleware("http")
async def request_metadata(request: Request, call_next):
request_id = request.headers.get("X-Request-Id", "")
if not request_id or len(request_id) > 128:
request_id = str(uuid.uuid4())
request.state.request_id = request_id
try:
response = await call_next(request)
except Exception:
logger.exception("unhandled request failure")
response = JSONResponse(
status_code=500,
content={
"error": {
"code": "internal_error",
"message": "Внутренняя ошибка",
"request_id": request_id,
}
},
)
response.headers["X-Request-Id"] = request_id
response.headers["X-Instance-Id"] = request.app.state.instance_id
return response
@app.exception_handler(APIError)
async def handle_api_error(request: Request, exc: APIError):
headers = {"WWW-Authenticate": exc.challenge} if exc.challenge else None
return JSONResponse(
status_code=exc.status_code,
content={
"error": {
"code": exc.code,
"message": exc.message,
"request_id": request.state.request_id,
}
},
headers=headers,
)
@app.exception_handler(RequestValidationError)
async def handle_validation_error(request: Request, exc: RequestValidationError):
return JSONResponse(
status_code=400,
content={
"error": {
"code": "invalid_request",
"message": "Некорректный запрос",
"request_id": request.state.request_id,
}
},
)
@app.exception_handler(StarletteHTTPException)
async def handle_http_error(request: Request, exc: StarletteHTTPException):
status = 404 if exc.status_code == 404 else exc.status_code
code = "not_found" if status == 404 else "invalid_request"
return JSONResponse(
status_code=status,
content={
"error": {
"code": code,
"message": "Объект не найден" if status == 404 else "Некорректный запрос",
"request_id": request.state.request_id,
}
},
)
@app.exception_handler(psycopg.Error)
async def handle_database_error(request: Request, exc: psycopg.Error):
logger.warning("database operation failed: %s", type(exc).__name__)
return JSONResponse(
status_code=503,
content={
"error": {
"code": "unavailable",
"message": "Сервис временно недоступен",
"request_id": request.state.request_id,
}
},
)
@app.exception_handler(PoolTimeout)
async def handle_pool_timeout(request: Request, exc: PoolTimeout):
return JSONResponse(
status_code=503,
content={
"error": {
"code": "unavailable",
"message": "Сервис временно недоступен",
"request_id": request.state.request_id,
}
},
)
def auth_error(challenge: str = 'Bearer realm="messenger"') -> APIError:
return APIError(401, "unauthorized", "Требуется действительная аутентификация", challenge)
def parse_uuid(value: str) -> uuid.UUID:
try:
return uuid.UUID(value)
except (ValueError, AttributeError, TypeError):
raise APIError(400, "invalid_request", "Некорректный UUID") from None
def authenticated_user(
request: Request,
authorization: Optional[str] = Header(default=None),
connection=Depends(get_connection),
) -> Dict[str, Any]:
if not authorization or not authorization.startswith("Bearer "):
raise auth_error()
token = authorization[7:]
if not token or len(token) > 256:
raise auth_error()
token_hash = hashlib.sha256(token.encode("utf-8")).digest()
now = datetime.now(timezone.utc)
cache = request.app.state.redis
cache_key = "session:" + token_hash.hex()
cached: Optional[Dict[str, Any]] = None
try:
raw = cache.get(cache_key)
if raw:
cached_value = json.loads(raw)
if isinstance(cached_value, dict):
cached = cached_value
else:
logger.warning("session cache entry has an invalid shape")
except (redis.RedisError, json.JSONDecodeError):
logger.warning("session cache read failed; using PostgreSQL")
try:
session = connection.execute(
"""
SELECT s.user_id, s.expires_at, s.revoked_at
FROM sessions AS s
WHERE s.token_hash = %s
""",
(token_hash,),
).fetchone()
except psycopg.Error as exc:
logger.warning("session lookup failed: %s", type(exc).__name__)
raise db_unavailable() from None
if not session or session["revoked_at"] is not None or session["expires_at"] <= now:
try:
cache.delete(cache_key)
except redis.RedisError:
logger.warning("expired session cache invalidation failed")
raise auth_error()
# PostgreSQL remains authoritative for expiry and revocation. Redis avoids
# a user-profile query on a cache hit.
if cached:
profile = cached.get("user")
if (
cached.get("user_id") == str(session["user_id"])
and isinstance(profile, dict)
and profile.get("id") == str(session["user_id"])
):
user = profile
else:
cached = None
lock_key = cache_key + ":fill-lock"
lock_token = str(uuid.uuid4())
lock_acquired = False
if not cached:
for _ in range(20):
try:
lock_acquired = bool(
cache.set(lock_key, lock_token, nx=True, px=5000)
)
if lock_acquired:
break
raw = cache.get(cache_key)
if raw:
cached_value = json.loads(raw)
if (
isinstance(cached_value, dict)
and cached_value.get("user_id") == str(session["user_id"])
and isinstance(cached_value.get("user"), dict)
and cached_value["user"].get("id") == str(session["user_id"])
):
user = cached_value["user"]
cached = cached_value
break
except (redis.RedisError, json.JSONDecodeError):
logger.warning("session cache single-flight failed; using PostgreSQL")
break
time.sleep(0.05)
if not cached:
logger.info("profile_cache_fill request_id=%s", request.state.request_id)
profile_row = connection.execute(
"""
SELECT id, username, display_name, created_at
FROM users WHERE id = %s
""",
(session["user_id"],),
).fetchone()
if not profile_row:
raise auth_error()
user = user_json(profile_row)
remaining = max(1, int((session["expires_at"] - now).total_seconds()))
if lock_acquired:
try:
cache.set(
cache_key,
json.dumps({"user_id": str(session["user_id"]), "user": user}),
ex=remaining,
)
except redis.RedisError:
logger.warning("session cache write failed; continuing with PostgreSQL")
if lock_acquired:
try:
cache.eval(
"if redis.call('get', KEYS[1]) == ARGV[1] "
"then return redis.call('del', KEYS[1]) else return 0 end",
1,
lock_key,
lock_token,
)
except redis.RedisError:
logger.warning("session cache fill lock release failed")
request.state.token_hash = token_hash
return user
@app.get("/health/live")
def live() -> Dict[str, str]:
return {"status": "ok"}
@app.get("/health/ready")
def ready(request: Request, connection=Depends(get_connection)) -> Dict[str, str]:
try:
connection.execute("SELECT 1")
request.app.state.redis.ping()
except (psycopg.Error, redis.RedisError):
raise db_unavailable() from None
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
def register_user(payload: UserInput, connection=Depends(get_connection)):
user_id = uuid.uuid4()
password_hash = PASSWORD_HASHER.hash(payload.password)
try:
with connection.transaction():
row = connection.execute(
"""
INSERT INTO users (id, username, display_name, password_hash)
VALUES (%s, %s, %s, %s)
RETURNING id, username, display_name, created_at
""",
(user_id, payload.username, payload.display_name, password_hash),
).fetchone()
except UniqueViolation:
raise APIError(409, "conflict", "Имя пользователя уже занято") from None
except psycopg.Error as exc:
logger.warning("user registration failed: %s", type(exc).__name__)
raise db_unavailable() from None
return user_json(row)
def decode_basic_credentials(authorization: Optional[str]) -> Tuple[str, str]:
challenge = 'Basic realm="messenger", charset="UTF-8"'
if not authorization or not authorization.startswith("Basic "):
raise auth_error(challenge)
try:
raw = base64.b64decode(authorization[6:], validate=True).decode("utf-8")
username, password = raw.split(":", 1)
except (binascii.Error, UnicodeDecodeError, ValueError):
raise auth_error(challenge) from None
if not USERNAME_PATTERN.fullmatch(username) or not 12 <= len(password) <= 128:
raise auth_error(challenge)
return username, password
@app.post("/api/v1/auth/sessions", status_code=201)
def create_session(
request: Request,
authorization: Optional[str] = Header(default=None),
connection=Depends(get_connection),
):
username, password = decode_basic_credentials(authorization)
row = connection.execute(
"""
SELECT id, username, display_name, password_hash, created_at
FROM users WHERE username = %s
""",
(username,),
).fetchone()
if not row:
raise auth_error('Basic realm="messenger", charset="UTF-8"')
try:
PASSWORD_HASHER.verify(row["password_hash"], password)
except (VerifyMismatchError, VerificationError, InvalidHashError):
raise auth_error('Basic realm="messenger", charset="UTF-8"') from None
token = secrets.token_urlsafe(32)
token_hash = hashlib.sha256(token.encode("utf-8")).digest()
expires_at = datetime.now(timezone.utc) + timedelta(seconds=session_ttl_seconds())
try:
with connection.transaction():
connection.execute(
"""
INSERT INTO sessions (token_hash, user_id, expires_at)
VALUES (%s, %s, %s)
""",
(token_hash, row["id"], expires_at),
)
except psycopg.Error as exc:
logger.warning("session creation failed: %s", type(exc).__name__)
raise db_unavailable() from None
user = user_json(row)
try:
request.app.state.redis.set(
"session:" + token_hash.hex(),
json.dumps({"user_id": str(row["id"]), "user": user}),
ex=session_ttl_seconds(),
)
except redis.RedisError:
logger.warning("session cache write failed; session remains durable in PostgreSQL")
return {
"token": token,
"token_type": "Bearer",
"expires_at": utc_string(expires_at),
"user": user,
}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(
request: Request,
user: Dict[str, Any] = Depends(authenticated_user),
connection=Depends(get_connection),
):
token_hash: bytes = request.state.token_hash
try:
with connection.transaction():
result = connection.execute(
"""
UPDATE sessions SET revoked_at = clock_timestamp()
WHERE token_hash = %s AND revoked_at IS NULL
""",
(token_hash,),
)
if result.rowcount != 1:
raise auth_error()
except APIError:
raise
except psycopg.Error as exc:
logger.warning("session revocation failed: %s", type(exc).__name__)
raise db_unavailable() from None
try:
request.app.state.redis.delete("session:" + token_hash.hex())
except redis.RedisError:
logger.warning("revoked session cache invalidation failed")
return Response(status_code=204)
@app.get("/api/v1/users/me")
def current_user(user: Dict[str, Any] = Depends(authenticated_user)):
return user
def member_ids_for(connection, chat_id: uuid.UUID) -> List[str]:
rows = connection.execute(
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id",
(chat_id,),
).fetchall()
return [str(row["user_id"]) for row in rows]
def require_chat_member(
connection, chat_id: uuid.UUID, user_id: uuid.UUID
) -> Dict[str, Any]:
row = connection.execute(
"""
SELECT c.id, c.title, c.created_at
FROM chats AS c JOIN chat_members AS cm ON cm.chat_id = c.id
WHERE c.id = %s AND cm.user_id = %s
""",
(chat_id, user_id),
).fetchone()
if not row:
raise APIError(404, "not_found", "Объект не найден")
return row
@app.post("/api/v1/chats", status_code=201)
def create_chat(
payload: ChatInput,
user: Dict[str, Any] = Depends(authenticated_user),
connection=Depends(get_connection),
):
ids = [parse_uuid(member_id) for member_id in payload.member_ids]
if len(set(ids)) != len(ids) or uuid.UUID(user["id"]) not in ids:
raise APIError(400, "invalid_request", "Некорректный список участников")
chat_id = uuid.uuid4()
try:
with connection.transaction():
found = connection.execute(
"SELECT id FROM users WHERE id = ANY(%s)",
(ids,),
).fetchall()
if len(found) != len(ids):
raise APIError(400, "invalid_request", "Участник не существует")
chat = connection.execute(
"""
INSERT INTO chats (id, title) VALUES (%s, %s)
RETURNING id, title, created_at
""",
(chat_id, payload.title),
).fetchone()
for member_id in ids:
connection.execute(
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
(chat_id, member_id),
)
except APIError:
raise
except psycopg.Error as exc:
logger.warning("chat creation rolled back: %s", type(exc).__name__)
raise db_unavailable() from None
return chat_json(chat, [str(member_id) for member_id in sorted(ids)])
@app.get("/api/v1/chats")
def list_chats(
user: Dict[str, Any] = Depends(authenticated_user),
connection=Depends(get_connection),
limit: int = 50,
cursor: Optional[str] = None,
):
if limit < 1 or limit > 100:
raise APIError(400, "invalid_request", "limit должен быть от 1 до 100")
cursor_values = decode_cursor(cursor, "chats") if cursor else None
parameters: List[Any] = [uuid.UUID(user["id"])]
clause = ""
if cursor_values:
clause = "AND (c.created_at, c.id) > (%s, %s)"
parameters.extend(cursor_values)
parameters.append(limit + 1)
rows = connection.execute(
"""
SELECT c.id, c.title, c.created_at
FROM chats c JOIN chat_members cm ON cm.chat_id = c.id
WHERE cm.user_id = %s
"""
+ clause
+ " ORDER BY c.created_at, c.id LIMIT %s",
parameters,
).fetchall()
has_more = len(rows) > limit
rows = rows[:limit]
items = [
chat_json(row, member_ids_for(connection, row["id"]))
for row in rows
]
next_cursor = encode_cursor("chats", rows[-1]) if has_more and rows else None
return {"items": items, "next_cursor": next_cursor}
@app.get("/api/v1/chats/{chat_id}")
def get_chat(
chat_id: str,
user: Dict[str, Any] = Depends(authenticated_user),
connection=Depends(get_connection),
):
parsed_id = parse_uuid(chat_id)
row = require_chat_member(connection, parsed_id, uuid.UUID(user["id"]))
return chat_json(row, member_ids_for(connection, parsed_id))
def encode_cursor(kind: str, row: Dict[str, Any]) -> str:
payload = json.dumps(
[CURSOR_VERSION, kind, str(row["created_at"]), str(row["id"])],
separators=(",", ":"),
).encode("utf-8")
return base64.urlsafe_b64encode(payload).decode("ascii").rstrip("=")
def decode_cursor(value: str, kind: str) -> Tuple[datetime, uuid.UUID]:
try:
padded = value + "=" * (-len(value) % 4)
decoded = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")))
if (
not isinstance(decoded, list)
or len(decoded) != 4
or decoded[0] != CURSOR_VERSION
or decoded[1] != kind
):
raise ValueError
created_at = datetime.fromisoformat(decoded[2])
if created_at.tzinfo is None:
raise ValueError
return created_at, uuid.UUID(decoded[3])
except (ValueError, TypeError, UnicodeError, json.JSONDecodeError):
raise APIError(400, "invalid_request", "Некорректный cursor") from None
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def create_message(
chat_id: str,
payload: MessageInput,
user: Dict[str, Any] = Depends(authenticated_user),
connection=Depends(get_connection),
):
parsed_chat_id = parse_uuid(chat_id)
chat = require_chat_member(connection, parsed_chat_id, uuid.UUID(user["id"]))
if not payload.text.strip():
raise APIError(400, "invalid_request", "Сообщение не может быть пустым")
row = connection.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text)
VALUES (%s, %s, %s, %s)
RETURNING id, chat_id, sender_id, text, created_at
""",
(uuid.uuid4(), chat["id"], uuid.UUID(user["id"]), payload.text),
).fetchone()
return message_json(row)
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(
chat_id: str,
user: Dict[str, Any] = Depends(authenticated_user),
connection=Depends(get_connection),
limit: int = 50,
cursor: Optional[str] = None,
):
if limit < 1 or limit > 100:
raise APIError(400, "invalid_request", "limit должен быть от 1 до 100")
parsed_chat_id = parse_uuid(chat_id)
chat = require_chat_member(connection, parsed_chat_id, uuid.UUID(user["id"]))
cursor_values = decode_cursor(cursor, str(parsed_chat_id)) if cursor else None
parameters: List[Any] = [chat["id"]]
clause = ""
if cursor_values:
clause = "AND (created_at, id) > (%s, %s)"
parameters.extend(cursor_values)
parameters.append(limit + 1)
rows = connection.execute(
"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages WHERE chat_id = %s
"""
+ clause
+ " ORDER BY created_at, id LIMIT %s",
parameters,
).fetchall()
has_more = len(rows) > limit
rows = rows[:limit]
items = [message_json(row) for row in rows]
next_cursor = encode_cursor(str(parsed_chat_id), rows[-1]) if has_more and rows else None
return {"items": items, "next_cursor": next_cursor}
+35
View File
@@ -0,0 +1,35 @@
from pathlib import Path
import psycopg
from app.settings import database_connection
def main() -> None:
migration_dir = Path(__file__).with_name("migrations")
with psycopg.connect(**database_connection(), autocommit=False) as connection:
connection.execute(
"""
CREATE TABLE IF NOT EXISTS schema_migrations (
version varchar(255) PRIMARY KEY,
applied_at timestamptz NOT NULL DEFAULT clock_timestamp()
)
"""
)
for migration in sorted(migration_dir.glob("*.sql")):
already_applied = connection.execute(
"SELECT 1 FROM schema_migrations WHERE version = %s",
(migration.name,),
).fetchone()
if already_applied:
continue
connection.execute(migration.read_text(encoding="utf-8"))
connection.execute(
"INSERT INTO schema_migrations (version) VALUES (%s)",
(migration.name,),
)
connection.commit()
if __name__ == "__main__":
main()
+54
View File
@@ -0,0 +1,54 @@
CREATE TABLE IF NOT EXISTS users (
id uuid PRIMARY KEY,
username varchar(32) NOT NULL UNIQUE,
display_name varchar(100) NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_nonblank CHECK (length(btrim(display_name)) > 0)
);
CREATE TABLE IF NOT EXISTS chats (
id uuid PRIMARY KEY,
title varchar(100) NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT chats_title_nonblank CHECK (length(btrim(title)) > 0)
);
CREATE TABLE IF NOT EXISTS chat_members (
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX IF NOT EXISTS chat_members_by_user
ON chat_members (user_id, chat_id);
CREATE TABLE IF NOT EXISTS messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
text varchar(4000) NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT messages_text_nonblank CHECK (length(btrim(text)) > 0)
);
CREATE INDEX IF NOT EXISTS messages_history_keyset
ON messages (chat_id, created_at, id);
CREATE TABLE IF NOT EXISTS sessions (
token_hash bytea PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at timestamptz NOT NULL,
revoked_at timestamptz,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE INDEX IF NOT EXISTS sessions_active_by_expiry
ON sessions (expires_at)
WHERE revoked_at IS NULL;
CREATE TABLE IF NOT EXISTS schema_migrations (
version varchar(255) PRIMARY KEY,
applied_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
+54
View File
@@ -0,0 +1,54 @@
import os
from pathlib import Path
from typing import Dict, Optional
def read_setting(
name: str,
file_name: str,
default: Optional[str] = None,
default_file: Optional[str] = None,
) -> str:
configured_secret_path = os.environ.get(file_name)
secret_path = configured_secret_path or default_file
if secret_path and (configured_secret_path or Path(secret_path).is_file()):
try:
return Path(secret_path).read_text(encoding="utf-8").strip()
except OSError as exc:
raise RuntimeError("Unable to read configured secret file") from exc
value = os.environ.get(name, default)
if value is None:
if default_file:
raise RuntimeError(
"Required setting is missing: "
+ name
+ "; set "
+ file_name
+ " or mount the secret at "
+ default_file
)
raise RuntimeError("Required application setting is missing: " + name)
return value
def database_connection() -> Dict[str, object]:
return {
"host": os.environ.get("DB_HOST", "localhost"),
"port": int(os.environ.get("DB_PORT", "5432")),
"dbname": os.environ.get("DB_NAME", "messenger"),
"user": os.environ.get("DB_USER", "messenger"),
"password": read_setting(
"DB_PASSWORD",
"DB_PASSWORD_FILE",
default_file="/run/secrets/database_password",
),
"connect_timeout": int(os.environ.get("DB_CONNECT_TIMEOUT_SECONDS", "3")),
"options": "-c statement_timeout=5000 -c lock_timeout=3000",
}
def session_ttl_seconds() -> int:
value = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
if value < 1:
raise RuntimeError("SESSION_TTL_SECONDS must be at least 1")
return value
+83
View File
@@ -0,0 +1,83 @@
services:
postgres:
image: postgres:16.6-alpine
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/database_password
secrets:
- database_password
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 3s
timeout: 3s
retries: 20
restart: unless-stopped
networks:
- backend
redis:
image: redis:7.4.2-alpine
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 3s
timeout: 3s
retries: 20
restart: unless-stopped
networks:
- backend
api:
build:
context: .
dockerfile: Dockerfile
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DB_HOST: postgres
DB_PORT: 5432
DB_NAME: messenger
DB_USER: messenger
DB_PASSWORD_FILE: /run/secrets/database_password
DB_POOL_MAX_SIZE: ${DB_POOL_MAX_SIZE:-10}
REDIS_URL: redis://redis:6379/0
secrets:
- database_password
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
ports:
- "${APP_PORT:-8080}:8080"
healthcheck:
test:
- CMD
- python
- -c
- "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"
interval: 5s
timeout: 3s
retries: 20
start_period: 10s
restart: unless-stopped
networks:
- backend
secrets:
database_password:
file: ./secrets/database_password
volumes:
postgres_data:
redis_data:
networks:
backend:
driver: bridge
+64
View File
@@ -0,0 +1,64 @@
Проверки на Compose, 2026-11-09
Профиль: локальный Docker Compose, API, PostgreSQL 16.6, Redis 7.4.2.
Пользователи, чаты и сообщения в тестах синтетические.
Перед проверкой у существующего PostgreSQL volume пароль роли messenger не
совпадал с текущим secrets/database_password. Пароль роли был синхронизирован
с локальным secret через локальный psql-доступ; volume и данные не удалялись.
После этого API применил миграции и стал healthy.
PASS: docker compose up -d --build
PASS: curl http://localhost:8080/health/ready -> HTTP 200 {"status":"ok"}
PASS: make test
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
PASS: make test-persistence ACTION_SCRIPT=scripts/restart.sh
PASS: persistence preserved confirmed data and existing session.
Hook перезапускал postgres, redis и api; volumes не удалялись.
PASS: make test-grade4
PASS: registration race, invalid password, logout and dependency outages.
Redis был остановлен: авторизация продолжила работать через PostgreSQL.
PostgreSQL был остановлен: ready и защищённый запрос вернули 503;
после запуска PostgreSQL API восстановился.
PASS: make test-rollback
PASS: injected membership failure rolled back the chat transaction.
Тестовый триггер прерывал вставку второго участника; проверено отсутствие
строки чата после rollback. Триггер/функция тестом удалены.
PASS: SESSION_TTL_SECONDS=2 docker compose up -d --force-recreate api
make test-expiry
PASS: session expired at its configured deadline.
После теста API пересоздан с SESSION_TTL_SECONDS=3600.
PASS: make explain-history
Fixture: 10000 сообщений; после анализа выполнен ROLLBACK.
Limit (cost=0.29..4.41 rows=51 width=78)
(actual time=0.007..0.012 rows=51 loops=1)
Buffers: shared hit=3
-> Index Scan using messages_history_keyset on messages
(cost=0.29..808.63 rows=9999 width=78)
(actual time=0.006..0.009 rows=51 loops=1)
Index Cond: chat_id = fixture AND (created_at, id) > cursor
Buffers: shared hit=3
Planning Time: 0.130 ms
Execution Time: 0.031 ms
SELECT count(*) вернул 10000; транзакция завершена ROLLBACK.
Ограничения: single-node локальный стенд; один прогретый EXPLAIN не является
нагрузочным тестом и не подтверждает HA при потере host. Изменение пароля
потребовалось из-за рассогласования secret с ранее созданным volume; само
изменение секрета не удаляло данные.
Предыдущая изолированная локальная проверка 2026-10-30 на PostgreSQL 16.11
с Redis test double была предварительной; результаты полного Compose-прогона
выше являются более свежими и проверяют реальные контейнеры.
Повторный прогон 2026-11-10 на отдельном Compose-проекте с чистыми именованными
volumes, PostgreSQL 16.6 и Redis 7.4.2:
PASS: make check
PASS: make validate
PASS: make test
PASS: make test-persistence ACTION_SCRIPT=scripts/restart.sh
PASS: make test-grade4
PASS: make test-rollback; проверено отсутствие тестового триггера после cleanup
PASS: SESSION_TTL_SECONDS=2 make test-expiry; затем восстановлен TTL 3600 и smoke
PASS: make explain-history; 10000 строк, Index Scan, 51 строка, 3 shared hits,
Execution Time 0.034 ms; fixture завершён ROLLBACK.
PASS: schema_migrations содержит только 001_initial.sql после повторных стартов.
+3 -3
View File
@@ -1,7 +1,7 @@
# Инфраструктура студента
Здесь разместите конфигурации выбранных сервисов; основную топологию — в корневом compose.yaml/stack.yaml. `compose.example.yaml` — только worksheet ролей и намеренно не запускается. `contracts/infrastructure.json` задаёт минимальные роли, не готовые образы/пароли.
Основная Compose-топология находится в корневом compose.yaml. `compose.example.yaml` — только worksheet ролей и намеренно не запускается. `contracts/infrastructure.json` задаёт минимальные роли.
В REPORT.md сопоставьте роль → service name → версия/digest → health/readiness → volume → сеть/порт → способ передачи credentials. Приведите bootstrap (schema, bucket, broker topology, а с lab6 provisioning) и безопасное повторение этих команд.
Роли: API → `api` (сборка из Dockerfile) → `/health/ready` → порт 8080; PostgreSQL → `postgres:16.6-alpine` → `pg_isready` → именованный `postgres_data`; Redis → `redis:7.4.2-alpine` → `redis-cli ping` → `redis_data` с AOF. Все сервисы в закрытой сети `backend`; наружу опубликован только API. Пароль PostgreSQL передаётся через локальный Compose secret `secrets/database_password`, игнорируемый Git. Миграция выполняется идемпотентно при старте API.
Приложение строится из исходников. Не используйте заранее существующий образ преподавательского сервера вместо своей реализации. Restart hook перезапускает все соответствующие stores с volumes; failover hook останавливает только заданную API-реплику.
Restart hook перезапускает API и оба хранилища без удаления volumes. Образы инфраструктуры зафиксированы тегами; перед production-использованием замените теги на проверенные digest и добавьте управление ротацией secrets. Это учебная локальная конфигурация.
+5
View File
@@ -0,0 +1,5 @@
argon2-cffi==23.1.0
fastapi==0.115.6
psycopg[binary,pool]==3.2.4
redis==5.2.1
uvicorn[standard]==0.34.0
+39
View File
@@ -0,0 +1,39 @@
BEGIN;
SELECT gen_random_uuid()::text AS bench_user_id,
gen_random_uuid()::text AS bench_chat_id,
'bench_' || substr(replace(gen_random_uuid()::text, '-', ''), 1, 24) AS bench_username
\gset
INSERT INTO users (id, username, display_name, password_hash)
VALUES (:'bench_user_id'::uuid, :'bench_username', 'Benchmark fixture', 'not-used');
INSERT INTO chats (id, title)
VALUES (:'bench_chat_id'::uuid, 'Rollback-only history benchmark');
INSERT INTO chat_members (chat_id, user_id)
VALUES (:'bench_chat_id'::uuid, :'bench_user_id'::uuid);
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
:'bench_chat_id'::uuid,
:'bench_user_id'::uuid,
'benchmark message ' || message_number,
clock_timestamp() + message_number * interval '1 microsecond'
FROM generate_series(1, 10000) AS message_number;
ANALYZE messages;
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = :'bench_chat_id'::uuid
AND (created_at, id) > ('-infinity'::timestamptz, '00000000-0000-0000-0000-000000000000'::uuid)
ORDER BY created_at, id
LIMIT 51;
SELECT count(*) AS benchmark_messages
FROM messages
WHERE chat_id = :'bench_chat_id'::uuid;
ROLLBACK;
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose restart postgres redis api
+8
View File
@@ -55,3 +55,11 @@ make test-security BASE_URL=https://localhost:8443 CA_FILE=/absolute/path/to/ca.
## Что ещё остаётся доказать
Smoke не доказывает persistence, число реальных контейнеров, durability брокера, outbox, отсутствие утечек/уязвимостей, полноту telemetry или выполнение уровня 4/5. Конкурентные/нагрузочные/негативные проверки своего решения добавляйте отдельно. Список защиты текущей лабы находится в README.md. Проверки рассчитаны на localhost-стенд, не на production.
## Redis single-flight, track 5
```sh
make test-track5-cache BASE_URL=http://localhost:8080
```
Тест требует работающий Compose-стенд, Docker Compose CLI и доступные логи сервиса `api`. Он сбрасывает только ключ профиля созданной им тестовой сессии, выполняет конкурентные холодные и прогретые чтения, считает события `profile_cache_fill` по уникальным request ID и выводит p95 latency. Ожидается один запрос профиля в PostgreSQL на холодную конкурентную группу и ноль на прогретую. Затем тест перезапускает Redis, удаляет только этот тестовый ключ и проверяет повторную загрузку из PostgreSQL. Идентификаторы событий не содержат токенов или персональных данных.
+119
View File
@@ -0,0 +1,119 @@
#!/usr/bin/env python3
import hashlib
import math
import subprocess
import time
import uuid
from concurrent.futures import ThreadPoolExecutor
from client import Client, Failure, arguments, check, run
def docker(*command):
return subprocess.run(
["docker", "compose", *command],
check=True,
capture_output=True,
text=True,
timeout=15,
)
def fill_events(request_ids):
logs = docker("logs", "--no-color", "--since", "5m", "api").stdout
return {
request_id
for request_id in request_ids
if "profile_cache_fill request_id=" + request_id in logs
}
def ready(client):
for _ in range(60):
try:
client.call("GET", "/health/ready", schema="Health")
return
except Failure:
time.sleep(1)
raise Failure("API did not become ready after Redis restart")
def p95_milliseconds(results):
elapsed = sorted(result["elapsed"] for result in results)
return elapsed[math.ceil(0.95 * len(elapsed)) - 1] * 1000
def main():
args = arguments("Redis profile-cache single-flight consistency check")
client = Client(args.base_url, args.ca_file, timeout=10)
client.call("GET", "/health/ready", schema="Health")
actor = client.user("cache")
cache_key = "session:" + hashlib.sha256(actor["token"].encode()).hexdigest()
docker("exec", "-T", "redis", "redis-cli", "DEL", cache_key)
def get_profile(request_id):
return Client(args.base_url, args.ca_file, timeout=10).call(
"GET",
"/api/v1/users/me",
actor=actor,
schema="User",
headers={"X-Request-Id": request_id},
)
cold_ids = ["cache-cold-" + uuid.uuid4().hex for _ in range(16)]
with ThreadPoolExecutor(max_workers=len(cold_ids)) as executor:
cold_results = list(executor.map(get_profile, cold_ids))
check(
all(result["json"] == actor["user"] for result in cold_results),
"concurrent cold-cache requests returned inconsistent profiles",
)
cold_fills = fill_events(cold_ids)
check(
len(cold_fills) == 1,
"cold-cache request burst filled the profile cache "
+ str(len(cold_fills))
+ " times instead of once",
)
warm_ids = ["cache-warm-" + uuid.uuid4().hex for _ in range(16)]
with ThreadPoolExecutor(max_workers=len(warm_ids)) as executor:
warm_results = list(executor.map(get_profile, warm_ids))
check(
all(result["json"] == actor["user"] for result in warm_results),
"concurrent warm-cache requests returned inconsistent profiles",
)
check(not fill_events(warm_ids), "warm-cache requests unexpectedly queried profiles")
docker("restart", "redis")
ready(client)
docker("exec", "-T", "redis", "redis-cli", "DEL", cache_key)
restart_id = "cache-restart-" + uuid.uuid4().hex
restarted_result = get_profile(restart_id)
check(
restarted_result["json"] == actor["user"],
"profile read-after-Redis-restart returned inconsistent data",
)
check(
fill_events([restart_id]) == {restart_id},
"profile was not reloaded from PostgreSQL after Redis restart",
)
print(
"PASS: Redis single-flight; "
+ str(len(cold_ids))
+ " concurrent cold reads caused 1 profile SQL read "
+ "(vs up to "
+ str(len(cold_ids))
+ " without single-flight), "
+ str(len(warm_ids))
+ " warm reads caused 0; "
+ "cold p95="
+ format(p95_milliseconds(cold_results), ".1f")
+ "ms, warm p95="
+ format(p95_milliseconds(warm_results), ".1f")
+ "ms; cache restart recovered from PostgreSQL"
)
if __name__ == "__main__":
run(main)
+48
View File
@@ -0,0 +1,48 @@
#!/usr/bin/env python3
import base64
import time
from datetime import datetime, timezone
from client import Client, Failure, arguments, check, run, timestamp
def main():
args = arguments("Short session expiry acceptance check")
client = Client(args.base_url, args.ca_file)
client.call("GET", "/health/ready", schema="Health")
username = "expiry_" + __import__("uuid").uuid4().hex[:16]
password = "Expiry-test-" + __import__("uuid").uuid4().hex
user = client.call(
"POST",
"/api/v1/users",
201,
body={
"username": username,
"display_name": "Expiry test",
"password": password,
},
schema="User",
)["json"]
basic = base64.b64encode((username + ":" + password).encode()).decode()
session = client.call(
"POST",
"/api/v1/auth/sessions",
201,
headers={"Authorization": "Basic " + basic},
schema="Session",
)["json"]
expires_at = timestamp(session["expires_at"])
remaining = (expires_at - datetime.now(timezone.utc)).total_seconds()
check(0 < remaining <= 5, "start API with SESSION_TTL_SECONDS=2 for this check")
client.call("GET", "/api/v1/users/me", actor={"id": user["id"], "token": session["token"]}, schema="User")
time.sleep(max(0, remaining) + 0.2)
client.call(
"GET",
"/api/v1/users/me",
expected=401,
actor={"id": user["id"], "token": session["token"]},
)
print("PASS: session expired at its configured deadline")
if __name__ == "__main__":
run(main)
+106
View File
@@ -0,0 +1,106 @@
#!/usr/bin/env python3
import base64
import subprocess
from concurrent.futures import ThreadPoolExecutor
from client import Client, Failure, arguments, check, run
def main():
args = arguments("Grade 4 concurrency and dependency outage checks")
client = Client(args.base_url, args.ca_file, timeout=4)
client.call("GET", "/health/ready", schema="Health")
username = "race_" + __import__("uuid").uuid4().hex[:16]
password = "Concurrent-test-" + __import__("uuid").uuid4().hex
registration = {
"username": username,
"display_name": "Registration race",
"password": password,
}
def register_once():
return Client(args.base_url, args.ca_file, timeout=10).call(
"POST", "/api/v1/users", expected=[201, 409], body=registration
)["status"]
with ThreadPoolExecutor(max_workers=8) as executor:
statuses = list(executor.map(lambda _: register_once(), range(8)))
check(statuses.count(201) == 1, "concurrent registration created other than one user")
check(statuses.count(409) == 7, "duplicate registrations did not return 409")
credentials = base64.b64encode((username + ":wrong-password-123").encode()).decode()
client.call(
"POST",
"/api/v1/auth/sessions",
expected=401,
headers={"Authorization": "Basic " + credentials},
)
actor = client.user("grade4")
client.call("GET", "/api/v1/users/me", expected=401)
missing_id = str(__import__("uuid").uuid4())
rollback_title = "invalid-member-" + __import__("uuid").uuid4().hex
client.call(
"POST",
"/api/v1/chats",
expected=400,
actor=actor,
body={"title": rollback_title, "member_ids": [actor["id"], missing_id]},
)
chats = client.call(
"GET", "/api/v1/chats?limit=100", actor=actor, schema="ChatPage"
)["json"]["items"]
check(all(chat["title"] != rollback_title for chat in chats), "invalid chat was persisted")
client.call("GET", "/api/v1/users/me", actor=actor, schema="User")
subprocess.run(
["docker", "compose", "stop", "redis"],
check=True,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
)
try:
client.call("GET", "/api/v1/users/me", actor=actor, schema="User")
finally:
subprocess.run(
["docker", "compose", "start", "redis"],
check=True,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
)
client.call("GET", "/health/ready", schema="Health")
subprocess.run(
["docker", "compose", "stop", "postgres"],
check=True,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
)
try:
client.call("GET", "/health/ready", expected=503)
client.call("GET", "/api/v1/users/me", expected=503, actor=actor)
finally:
subprocess.run(
["docker", "compose", "start", "postgres"],
check=True,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
)
for _ in range(60):
try:
client.call("GET", "/health/ready", schema="Health")
break
except Failure:
import time
time.sleep(1)
else:
raise Failure("PostgreSQL did not recover")
client.call("DELETE", "/api/v1/auth/sessions/current", expected=204, actor=actor)
client.call("GET", "/api/v1/users/me", expected=401, actor=actor)
print("PASS: registration race, invalid password, logout and dependency outages")
if __name__ == "__main__":
run(main)
+89
View File
@@ -0,0 +1,89 @@
#!/usr/bin/env python3
import subprocess
import uuid
from client import Client, Failure, arguments, check, run
TRIGGER = "grade4_fail_member_insert"
FUNCTION = "grade4_fail_member_insert_fn"
def psql(sql, capture=False):
return subprocess.run(
[
"docker",
"compose",
"exec",
"-T",
"postgres",
"psql",
"-U",
"messenger",
"-d",
"messenger",
"-v",
"ON_ERROR_STOP=1",
"-At",
"-c",
sql,
],
check=True,
stdout=subprocess.PIPE if capture else subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
text=True,
).stdout if capture else ""
def cleanup():
result = psql(
"DROP TRIGGER IF EXISTS " + TRIGGER + " ON chat_members; "
"DROP FUNCTION IF EXISTS " + FUNCTION + "(); "
"SELECT count(*) FROM pg_trigger "
"WHERE tgrelid = 'public.chat_members'::regclass "
"AND tgname = '" + TRIGGER + "' AND NOT tgisinternal",
capture=True,
)
check(result.strip().splitlines()[-1:] == ["0"], "rollback test trigger cleanup failed")
def main():
args = arguments("Force a failure during chat membership insert and verify transaction rollback")
client = Client(args.base_url, args.ca_file)
actor = client.user("rollback")
other = client.user("rollback_member")
title = "rollback-" + uuid.uuid4().hex
setup_sql = (
"DROP TRIGGER IF EXISTS " + TRIGGER + " ON chat_members; "
"DROP FUNCTION IF EXISTS " + FUNCTION + "(); "
"CREATE FUNCTION " + FUNCTION + "() RETURNS trigger LANGUAGE plpgsql AS $$ "
"BEGIN IF EXISTS (SELECT 1 FROM chat_members WHERE chat_id = NEW.chat_id) "
"THEN RAISE EXCEPTION 'injected rollback test'; END IF; "
"RETURN NEW; END $$; "
"CREATE TRIGGER " + TRIGGER
+ " BEFORE INSERT ON chat_members FOR EACH ROW EXECUTE FUNCTION "
+ FUNCTION + "(); "
"SELECT count(*) FROM pg_trigger WHERE tgrelid = 'public.chat_members'::regclass "
"AND tgname = '" + TRIGGER + "' AND tgenabled = 'O'"
)
try:
setup_result = psql(setup_sql, capture=True).strip().splitlines()
check(setup_result and setup_result[-1] == "1", "rollback test trigger was not installed")
client.call(
"POST",
"/api/v1/chats",
expected=503,
actor=actor,
body={"title": title, "member_ids": [actor["id"], other["id"]]},
)
count = psql(
"SELECT count(*) FROM chats WHERE title = '" + title + "'",
capture=True,
).strip()
check(count == "0", "failed chat creation left a partial chat row")
finally:
cleanup()
print("PASS: injected membership failure rolled back the chat transaction")
if __name__ == "__main__":
run(main)