Implement lab2 PostgreSQL sessions and Redis cache

This commit is contained in:
Polusikkkk
2026-10-16 18:23:50 +03:00
parent 65003b6119
commit 083dc49564
25 changed files with 2782 additions and 29 deletions
+11 -10
View File
@@ -1,11 +1,12 @@
# 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
# Шаблон для локального учебного стенда.
# Скопируйте в .env и задайте отдельный пароль PostgreSQL.
# Не добавляйте настоящий .env и действующие пароли в Git.
POSTGRES_PASSWORD=CHANGE_ME_LOCAL_ONLY
# Срок жизни новых сессий в секундах.
# Для обычного smoke и persistence используйте не менее 300.
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
# TTL кэша публичных данных пользователя в Redis, в секундах.
USER_CACHE_TTL_SECONDS=60
+26
View File
@@ -0,0 +1,26 @@
FROM python:3.12.10-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1
WORKDIR /app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
RUN addgroup --system appgroup \
&& adduser --system --ingroup appgroup --no-create-home appuser \
&& chown appuser:appgroup /app
COPY --chown=appuser:appgroup app ./app
COPY --chown=appuser:appgroup migrations ./migrations
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).read()" || exit 1
CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--no-access-log"]
+9 -1
View File
@@ -1,5 +1,5 @@
PYTHON ?= python3
BASE_URL ?= http://localhost:8080
BASE_URL ?= http://localhost:18081
CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
@@ -24,3 +24,11 @@ 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)
.PHONY: test-extra test-faults test-lab2
test-extra: ; BASE_URL="$(BASE_URL)" $(PYTHON) tests/lab2_checks.py
test-faults: ; BASE_URL="$(BASE_URL)" $(PYTHON) tests/lab2_faults.py
test-lab2: ; $(MAKE) test-extra && $(MAKE) test-faults
+421 -18
View File
@@ -1,37 +1,440 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Соколова Полина БВТ2304
- Целевая оценка: 4
- Трек уровня 5: не выполняется
- Commit/PR: добавить после публикации
Проверки выполнены на локальном стенде; результаты сохранены
в каталоге evidence/.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
### Требования и версии
Стенд разрабатывался и проверялся в Debian 12 под WSL 2.
Использованные версии:
- Docker Engine: 20.10.24+dfsg1.
- Docker Compose: v2.27.0.
- Базовый образ приложения: python:3.12.10-slim-bookworm.
- PostgreSQL: postgres:16.4-bookworm.
- Redis: redis:7.2.5-bookworm.
- Прямые зависимости Python закреплены в requirements.txt.
- Для публичных и собственных тестов на стороне хоста нужен Python 3.9+.
Внешний адрес API: http://localhost:18081.
Внутри контейнера приложение слушает 0.0.0.0:8080.
Порт 18081 выбран из-за занятых портов 8080 и 8081
в локальном окружении.
### Подготовка и запуск
Команды выполняются из корня репозитория:
```sh
cp .env.example .env
```
В новом локальном .env необходимо заменить
POSTGRES_PASSWORD=CHANGE_ME_LOCAL_ONLY отдельным учебным паролем.
Файл .env не добавляется в Git.
После настройки:
```sh
docker compose --env-file .env config --quiet
docker compose --env-file .env build api
docker compose --env-file .env up -d --wait api redis
docker compose ps -a
curl -i http://localhost:18081/health/live
curl -i http://localhost:18081/health/ready
```
Compose запускает PostgreSQL, одноразовый сервис migrate и API.
API зависит от готовности PostgreSQL и успешного завершения migrate.
Redis запускается явно в приведённой команде.
Миграции находятся в migrations/.
Программа app/migrate.py хранит применённые версии и контрольные
суммы в schema_migrations.
Повторный запуск:
```sh
docker compose --env-file .env run --rm migrate
```
Для уже применённого файла выводится:
```text
Already applied: 001_initial.sql
Migrations committed successfully
```
Повторная миграция не создаёт дубликаты таблиц и данных.
Изменение применённого SQL-файла обнаруживается по контрольной сумме.
Изменения схемы следует добавлять новой миграцией.
### Проверки
```sh
make check
make test BASE_URL=http://localhost:18081
make test-persistence \
BASE_URL=http://localhost:18081 \
ACTION_SCRIPT=scripts/restart.sh
make test-lab2 BASE_URL=http://localhost:18081
```
make test-lab2 последовательно запускает:
- make test-extra — шесть собственных проверок;
- make test-faults — отказы зависимостей и короткий TTL.
Сценарий test-faults управляет локальным Compose-стендом.
Его нельзя запускать параллельно с другими проверками или направлять
на произвольный удалённый сервер.
Проверка индекса:
```sh
docker compose exec -T postgres \
psql -X -U messenger -d messenger -v ON_ERROR_STOP=1 \
< scripts/explain_history.sql
```
Перед этим должен пройти smoke или собственные тесты:
SQL-сценарий использует одного существующего пользователя.
Каждый запуск SQL-сценария создаёт новый чат и 10 000 сообщений.
### Остановка и удаление данных
Остановка без удаления данных:
```sh
docker compose --env-file .env stop
```
Удаление контейнеров и сети с сохранением именованных volumes:
```sh
docker compose --env-file .env down
```
Только для намеренного полного сброса учебных данных:
```sh
docker compose --env-file .env down --volumes
```
Последняя команда удаляет volumes PostgreSQL и Redis.
Она не применяется в persistence-проверках.
Инструкция запуска подготовлена для нового окружения.
Отдельный эксперимент запуска из чистого clone с новыми volumes
на момент заполнения отчёта не выполнен.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
### Компоненты
```text
Клиент
|
| HTTP, localhost:18081
v
FastAPI
|-- PostgreSQL: источник истины
|-- Redis: кэш публичных данных пользователя
```
В PostgreSQL находятся:
- users — пользователи и хеши паролей;
- chats — чаты;
- chat_members — участники;
- messages — сообщения;
- sessions — хеши токенов и сроки действия сессий;
- schema_migrations — история применения миграций.
Приложение не хранит обязательное состояние в локальных словарях.
Для PostgreSQL и Redis настроены отдельные именованные volumes.
Порты хранилищ не публикуются на хосте.
API опубликован только на 127.0.0.1.
### Изменения относительно лабораторной 1
Сохранены операции пользователей, чатов, сообщений и история.
Изменено:
- in-memory хранилище заменено PostgreSQL;
- при регистрации требуется password;
- вход выполняется через Basic;
- бизнес-запросы используют Bearer вместо X-User-Id;
- добавлены expiry и logout;
- добавлены Redis, миграции и проверки отказов;
- пагинация выполняется SQL-запросом, без загрузки всей истории.
### Аутентификация и сессии
Пароли хешируются библиотекой argon2-cffi с Argon2id.
PasswordHasher использует параметры:
- time_cost=3;
- memory_cost=65536 KiB;
- parallelism=4;
- hash_len=32;
- salt_len=16.
Basic credentials декодируются как UTF-8.
Разделение username:password выполняется по первому двоеточию,
поэтому двоеточия внутри пароля сохраняются.
Токен сессии генерируется secrets.token_urlsafe(32):
используется 32 случайных байта.
Клиент получает исходный токен, в PostgreSQL сохраняется SHA-256 токена.
SHA-256 применяется к случайным токенам и файлам миграций,
но не заменяет password KDF.
Срок действия проверяется по времени PostgreSQL.
Истёкшая строка sessions не даёт доступ, даже если физически
ещё не удалена. Logout удаляет текущую сессию.
X-User-Id не используется для аутентификации.
Сессии сохраняются в PostgreSQL и переживают проверенный рестарт.
### Роль Redis
Redis содержит только публичные поля пользователя:
id, username, display_name, created_at.
Политика:
- источник истины — PostgreSQL;
- TTL кэша по умолчанию — 60 секунд;
- пароли, хеши паролей и токены не кэшируются;
- действительность сессии проверяется в PostgreSQL до чтения кэша;
- при отказе Redis профиль читается из PostgreSQL;
- при отказе PostgreSQL кэш не заменяет проверку сессии;
- изменение и удаление профиля отсутствуют в обязательном API,
поэтому в текущем контракте используется истечение по TTL.
Для Redis включён AOF с appendfsync everysec.
Сохранность сессий не зависит от Redis: они находятся в PostgreSQL.
### Транзакции и ограничения
В БД определены первичные и внешние ключи,
уникальность username и ограничения длины полей.
Составной внешний ключ messages(chat_id, sender_id)
ссылается на chat_members(chat_id, user_id).
Создание чата и добавление всех участников выполняются
в одной транзакции. Ошибка участника откатывает всю операцию.
При регистрации конкурентная уникальность обеспечивается
ограничением users_username_unique.
Конфликт username возвращается как HTTP 409.
Ответ об успешной записи формируется после выхода
из транзакционного блока с успешным COMMIT.
### Соединения и таймауты
Используется AsyncConnectionPool:
- min_size=1;
- max_size=5 на процесс API;
- ожидание соединения — 3 секунды;
- max_waiting=20;
- connect_timeout=3 секунды;
- statement_timeout=3000 ms;
- lock_timeout=2000 ms;
- idle_in_transaction_session_timeout=10000 ms.
Значения SQL передаются параметрами, а не конкатенацией
пользовательского ввода.
Redis:
- socket_connect_timeout=0.2 секунды;
- socket_timeout=0.2 секунды;
- max_connections=10.
Эти настройки не являются единой жёсткой границей времени
любого HTTP-запроса. В сценарии отказов отдельно проверяется
локальный бюджет запроса менее 10 секунд.
### Пагинация и конкурентные вставки
История сортируется по (created_at, id).
Курсор содержит эту пару и область запроса.
Курсор другого чата отклоняется.
Запрашивается limit + 1 строка для определения next_cursor.
Для неизменной истории продолжение использует строгое сравнение >,
поэтому последняя строка предыдущей страницы не повторяется.
Между HTTP-запросами общий snapshot не поддерживается.
При конкурентных вставках новая запись с ключом больше текущего
курсора может попасть в последующие страницы.
Запись с ключом не больше уже пройденного курсора может быть
пропущена текущим обходом.
Время назначается сервером БД через clock_timestamp().
Часы не являются уникальным идентификатором или гарантией
порядка COMMIT; для разрешения одинакового времени используется id.
### Конфигурация
.env.example соответствует реализации:
| Переменная | Назначение |
| --- | --- |
| POSTGRES_PASSWORD | Пароль PostgreSQL; передаётся приложению как PGPASSWORD |
| SESSION_TTL_SECONDS | Срок действия новых сессий, по умолчанию 3600 |
| USER_CACHE_TTL_SECONDS | TTL кэша пользователя, по умолчанию 60 |
Адреса и имена сервисов заданы в compose.yaml.
Реальные credentials и .env не включаются в репозиторий.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| Критерий | Команда / сценарий | Наблюдаемый результат | Доказательство |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Структура и синтаксис | make check | PASS; приложение этой проверкой не тестируется | Вывод команды |
| Публичный API | make test BASE_URL=http://localhost:18081 | PASS: lab2 public API scenario | evidence/smoke-final.txt |
| Миграции | Повторный запуск migrate | Already applied; в schema_migrations одна версия 001_initial.sql | Вывод миграции и SELECT |
| Сохранность данных и сессии | make test-persistence с scripts/restart.sh | PASS: confirmed data and existing session preserved | Результат теста; evidence/persistence-before.txt и persistence-after.txt |
| Реальный рестарт API и хранилищ | Сравнение StartedAt | Время запуска изменилось у API, PostgreSQL и Redis | evidence/persistence-before.txt; evidence/persistence-after.txt |
| Гонка username | Четыре конкурентные регистрации | Один 201 и три 409; вход созданного пользователя успешен | evidence/lab2-final.txt |
| Атомарность чата | Создание с неизвестным участником | 400; количество чатов и участников не изменилось; следующая валидная операция успешна | evidence/lab2-final.txt |
| Logout | Отзыв и повторное использование токена | 204 без тела; последующее чтение и повторный logout дают 401 | evidence/lab2-final.txt |
| Неверный пароль | Вход с неправильным паролем и неизвестным username | Одинаковый 401 и сообщение | evidence/lab2-final.txt |
| Unicode и двоеточия | Регистрация и вход с таким паролем | Успешный вход | evidence/lab2-final.txt |
| X-User-Id | Запрос без Bearer и попытка смены пользователя | Без токена 401; с токеном владелец не меняется | evidence/lab2-final.txt |
| Короткий expiry | SESSION_TTL_SECONDS=2 | Сначала 200, затем 401 | evidence/lab2-final.txt |
| Отказ Redis | Остановка Redis | Действующий токен работает через PostgreSQL; анонимный доступ запрещён | evidence/lab2-final.txt |
| Отказ PostgreSQL | Остановка БД при заполненном кэше | Защищённый запрос 503; live 200; ready 503; без токена 401 | evidence/lab2-final.txt |
| Возврат PostgreSQL | Запуск БД после отказа | Прежняя сессия снова работает | evidence/lab2-final.txt |
| Индекс истории | EXPLAIN на 10 000 сообщениях | Index Scan для первой и средней страницы | evidence/explain-history.txt |
| Pool и безопасные SQL-запросы | Проверка реализации | Ограниченный пул, таймауты, параметры SQL | app/db.py; app/store.py |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
### Persistence
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
Тест завершился:
```text
PASS: persistence preserved confirmed data and existing session.
```
Зафиксированные времена запуска до и после:
| Сервис | До, UTC | После, UTC |
| --- | --- | --- |
| API | 14:33:23 | 14:38:37 |
| PostgreSQL | 11:25:08 | 14:38:30 |
| Redis | 11:25:08 | 14:38:30 |
Дата эксперимента: 2026-10-16.
Полные временные метки находятся в evidence/.
Скрипт перезапускает API и оба используемых хранилища,
не удаляя volumes и не подменяя тестовые данные.
### Отказы и expiry: финальный запуск
| Воздействие | Наблюдение |
| --- | --- |
| Остановка Redis | Fallback успешен; защищённый запрос 0.140 s |
| Остановка PostgreSQL | Защищённый запрос получил 503 за 3.006 s |
| Возврат PostgreSQL | Прежняя сессия восстановила доступ |
| TTL=2 | Отказ по expiry наблюдался через 2.067 s после начала наблюдения |
| Завершение теста | PostgreSQL и Redis запущены, API healthy, TTL=3600 |
Это одиночный локальный сценарий, не статистическое измерение
задержек и не production SLA. Полное время восстановления
от момента запуска зависимости отдельно не измерялось.
Шесть собственных проверок в финальном запуске:
Ran 6 tests in 1.384s; OK.
### Индекс истории
Набор: 10 000 сообщений в одном чате,
1 000 различных created_at, по десять сообщений на временную метку.
Индекс:
```sql
CREATE INDEX messages_chat_created_id_idx
ON messages (chat_id, created_at, id);
```
Перед измерением выполнено ANALYZE messages.
| Запрос | План | Строки | Shared hit | Execution Time |
| --- | --- | --- | --- | --- |
| Первая страница | Index Scan | 51 | 3 | 0.025 ms |
| Страница после курсора около середины | Index Scan | 51 | 9 | 0.052 ms |
У второй страницы условие по (created_at, id)
входит в Index Cond. Отдельного Sort нет.
OFFSET используется только для подготовки контрольного
курсора в эксперименте, но не в запросах страниц приложения.
Показанные времена относятся к SQL-запросам на данном наборе,
а не к HTTP API. В плане указаны shared hits; холодный кэш
отдельно не исследовался.
Нагрузочное исследование RPS, p50/p95/p99 и потребления CPU/RAM
не проводилось. Лимиты CPU/RAM сервисов в Compose не заданы.
Исследовательские треки уровня 5 не заявляются.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- По одному экземпляру API, PostgreSQL и Redis.
Высокая доступность не реализована.
- При отказе PostgreSQL обязательный путь недоступен;
API возвращает контролируемую ошибку.
- Redis является необязательным для корректности кэшем.
- Проверен штатный рестарт с сохранением volumes,
не потеря диска, авария питания или повреждение данных.
- HTTP применяется только для локального изолированного стенда
с синтетическими данными.
- Постраничный обход не является snapshot всей истории.
- Устаревшие строки sessions автоматически не очищаются,
но не проходят проверку expiry.
- Нет rate limiting, вложений и фоновых workers:
они не входят в обязательную реализацию этой лабораторной.
- Теги образов и прямые зависимости закреплены;
digest образов и полный lock транзитивных зависимостей не добавлены.
- Проверки не являются полным security/fuzz/load suite.
- Нельзя заявлять запуск из чистого clone как выполненный
эксперимент без отдельной проверки.
## Использованные материалы и библиотеки
- Задание README.md и contracts/README.md.
- contracts/openapi.json и публичные tests/.
- Документация Docker Compose.
- Документация PostgreSQL: ограничения, транзакции,
индексы и EXPLAIN.
- Документация Psycopg 3 и psycopg-pool.
- Документация redis-py.
- Документация argon2-cffi.
- FastAPI, Uvicorn и стандартная библиотека Python.
View File
+108
View File
@@ -0,0 +1,108 @@
from __future__ import annotations
import base64
import binascii
import hashlib
import re
import secrets
from argon2 import PasswordHasher, Type
from argon2.exceptions import VerificationError
from starlette.concurrency import run_in_threadpool
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}", re.ASCII)
password_hasher = PasswordHasher(
time_cost=3,
memory_cost=65536,
parallelism=4,
hash_len=32,
salt_len=16,
type=Type.ID,
)
DUMMY_PASSWORD_HASH = password_hasher.hash(
secrets.token_urlsafe(32)
)
async def hash_password(password: str) -> str:
return await run_in_threadpool(
password_hasher.hash,
password,
)
async def verify_password(
password_hash: str,
password: str,
) -> bool:
try:
return await run_in_threadpool(
password_hasher.verify,
password_hash,
password,
)
except VerificationError:
return False
def parse_basic_credentials(
authorization: str | None,
) -> tuple[str, str] | None:
if authorization is None or len(authorization) > 2048:
return None
parts = authorization.split()
if len(parts) != 2 or parts[0].lower() != "basic":
return None
try:
decoded = base64.b64decode(
parts[1],
validate=True,
).decode("utf-8")
except (binascii.Error, UnicodeError, ValueError):
return None
username, separator, password = decoded.partition(":")
if not separator:
return None
if USERNAME_RE.fullmatch(username) is None:
return None
if not 12 <= len(password) <= 128:
return None
return username, password
def parse_bearer_token(
authorization: str | None,
) -> str | None:
if authorization is None or len(authorization) > 2048:
return None
parts = authorization.split()
if len(parts) != 2 or parts[0].lower() != "bearer":
return None
token = parts[1]
if re.fullmatch(r"[A-Za-z0-9_-]{43}", token) is None:
return None
return token
def generate_token() -> str:
return secrets.token_urlsafe(32)
def hash_token(token: str) -> str:
return hashlib.sha256(token.encode("ascii")).hexdigest()
+129
View File
@@ -0,0 +1,129 @@
from __future__ import annotations
import json
import logging
import os
from datetime import datetime, timezone
from uuid import UUID
from redis.asyncio import Redis
from redis.exceptions import RedisError
from app.store import store
logger = logging.getLogger("messenger.cache")
CACHE_TTL_SECONDS = int(
os.getenv("USER_CACHE_TTL_SECONDS", "60")
)
if not 1 <= CACHE_TTL_SECONDS <= 3600:
raise ValueError(
"USER_CACHE_TTL_SECONDS must be between 1 and 3600"
)
redis_client = Redis(
host=os.getenv("REDIS_HOST", "redis"),
port=int(os.getenv("REDIS_PORT", "6379")),
decode_responses=True,
socket_connect_timeout=0.2,
socket_timeout=0.2,
retry_on_timeout=False,
max_connections=10,
)
def serialize_user(user: dict) -> str:
created_at = user["created_at"]
return json.dumps(
{
"id": str(user["id"]),
"username": user["username"],
"display_name": user["display_name"],
"created_at": created_at.astimezone(
timezone.utc
).isoformat().replace("+00:00", "Z"),
},
ensure_ascii=False,
separators=(",", ":"),
)
def deserialize_user(
raw: str,
expected_id: UUID,
) -> dict:
data = json.loads(raw)
if not isinstance(data, dict):
raise ValueError("Invalid cached user")
expected_fields = {
"id",
"username",
"display_name",
"created_at",
}
if set(data) != expected_fields:
raise ValueError("Invalid cached user fields")
if not all(isinstance(value, str) for value in data.values()):
raise ValueError("Invalid cached user types")
user_id = UUID(data["id"])
if user_id != expected_id:
raise ValueError("Cached user ID mismatch")
created_at = datetime.fromisoformat(
data["created_at"].replace("Z", "+00:00")
)
if created_at.tzinfo is None:
raise ValueError("Cached timestamp has no timezone")
return {
"id": user_id,
"username": data["username"],
"display_name": data["display_name"],
"created_at": created_at,
}
async def get_cached_user(user_id: UUID) -> dict | None:
key = f"user:v1:{user_id}"
try:
raw = await redis_client.get(key)
if raw is not None:
return deserialize_user(raw, user_id)
except RedisError:
logger.warning("User cache read unavailable")
except (ValueError, TypeError, OverflowError):
logger.warning("Invalid user cache entry ignored")
user = await store.get_user(user_id)
if user is None:
return None
try:
await redis_client.set(
key,
serialize_user(user),
ex=CACHE_TTL_SECONDS,
)
except RedisError:
logger.warning("User cache write unavailable")
return user
async def close_cache() -> None:
await redis_client.aclose()
+44
View File
@@ -0,0 +1,44 @@
from __future__ import annotations
import os
from psycopg.rows import dict_row
from psycopg_pool import AsyncConnectionPool
pool = AsyncConnectionPool(
conninfo="",
kwargs={
"host": os.getenv("PGHOST", "postgres"),
"port": int(os.getenv("PGPORT", "5432")),
"dbname": os.getenv("PGDATABASE", "messenger"),
"user": os.getenv("PGUSER", "messenger"),
"password": os.environ.get("PGPASSWORD", ""),
"connect_timeout": 3,
"options": (
"-c statement_timeout=3000 "
"-c lock_timeout=2000 "
"-c idle_in_transaction_session_timeout=10000"
),
"row_factory": dict_row,
},
min_size=1,
max_size=5,
timeout=3,
max_waiting=20,
open=False,
check=AsyncConnectionPool.check_connection,
)
async def open_db() -> None:
await pool.open(wait=True, timeout=10)
async def close_db() -> None:
await pool.close()
async def check_db() -> None:
async with pool.connection() as conn:
await conn.execute("SELECT 1")
+655
View File
@@ -0,0 +1,655 @@
from __future__ import annotations
import base64
import binascii
import json
import logging
import os
import re
from contextlib import asynccontextmanager
from datetime import datetime, timezone
from uuid import UUID, uuid4
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse, Response
from psycopg import InterfaceError, OperationalError
from psycopg.errors import LockNotAvailable, QueryCanceled
from psycopg_pool import PoolTimeout, TooManyRequests
from starlette.exceptions import HTTPException
from app.auth import (
DUMMY_PASSWORD_HASH,
USERNAME_RE,
generate_token,
hash_password,
hash_token,
parse_basic_credentials,
parse_bearer_token,
verify_password,
)
from app.cache import close_cache, get_cached_user
from app.db import check_db, close_db, open_db
from app.store import InvalidMembersError, store
logger = logging.getLogger("messenger.api")
SESSION_TTL_SECONDS = int(
os.getenv("SESSION_TTL_SECONDS", "3600")
)
if SESSION_TTL_SECONDS < 1:
raise ValueError("SESSION_TTL_SECONDS must be positive")
class ApiError(Exception):
def __init__(
self,
status: int,
code: str,
message: str,
challenge: str | None = None,
):
super().__init__(message)
self.status = status
self.code = code
self.message = message
self.challenge = challenge
def invalid(message: str = "Некорректный запрос") -> ApiError:
return ApiError(400, "invalid_request", message)
def unauthorized(scheme: str = "Bearer") -> ApiError:
if scheme == "Basic":
challenge = 'Basic realm="messenger", charset="UTF-8"'
else:
challenge = 'Bearer realm="messenger"'
return ApiError(
401,
"unauthorized",
"Недействительная аутентификация",
challenge,
)
def not_found() -> ApiError:
return ApiError(404, "not_found", "Объект не найден")
def utc_text(value: datetime) -> str:
return (
value.astimezone(timezone.utc)
.isoformat(timespec="microseconds")
.replace("+00:00", "Z")
)
def to_json(value):
if isinstance(value, UUID):
return str(value)
if isinstance(value, datetime):
return utc_text(value)
if isinstance(value, dict):
return {
key: to_json(item)
for key, item in value.items()
}
if isinstance(value, (list, tuple)):
return [to_json(item) for item in value]
return value
def json_response(value, status: int = 200) -> JSONResponse:
return JSONResponse(
status_code=status,
content=to_json(value),
)
def error_response(
request: Request,
error: ApiError,
) -> JSONResponse:
request_id = getattr(
request.state,
"request_id",
str(uuid4()),
)
headers = {"X-Request-Id": request_id}
if error.challenge is not None:
headers["WWW-Authenticate"] = error.challenge
return JSONResponse(
status_code=error.status,
content={
"error": {
"code": error.code,
"message": error.message,
"request_id": request_id,
}
},
headers=headers,
)
@asynccontextmanager
async def lifespan(app: FastAPI):
try:
await open_db()
yield
finally:
await close_cache()
await close_db()
app = FastAPI(
title="PostgreSQL messenger — Lab 2",
docs_url=None,
redoc_url=None,
openapi_url=None,
lifespan=lifespan,
)
@app.middleware("http")
async def request_middleware(request: Request, call_next):
request.state.request_id = str(uuid4())
try:
response = await call_next(request)
except ApiError as exc:
response = error_response(request, exc)
except (
OperationalError,
InterfaceError,
PoolTimeout,
TooManyRequests,
QueryCanceled,
LockNotAvailable,
) as exc:
logger.warning(
"Database unavailable request_id=%s error_type=%s",
request.state.request_id,
type(exc).__name__,
)
response = error_response(
request,
ApiError(
503,
"unavailable",
"Сервис временно недоступен",
),
)
except Exception as exc:
logger.error(
"Unhandled error request_id=%s error_type=%s",
request.state.request_id,
type(exc).__name__,
)
response = error_response(
request,
ApiError(
500,
"internal_error",
"Внутренняя ошибка сервера",
),
)
response.headers["X-Request-Id"] = request.state.request_id
return response
@app.exception_handler(RequestValidationError)
async def validation_error_handler(request: Request, exc):
return error_response(request, invalid())
@app.exception_handler(HTTPException)
async def http_error_handler(request: Request, exc: HTTPException):
if exc.status_code == 404:
error = not_found()
else:
error = invalid("Недопустимый HTTP-запрос")
return error_response(request, error)
def parse_uuid(value: object) -> UUID:
if not isinstance(value, str):
raise invalid("Некорректный UUID")
try:
return UUID(value)
except ValueError:
raise invalid("Некорректный UUID") from None
def valid_text(value: object, maximum: int) -> bool:
return (
isinstance(value, str)
and 1 <= len(value) <= maximum
and bool(value.strip())
)
async def read_payload(
request: Request,
expected_fields: set[str],
) -> dict:
content_type = (
request.headers.get("content-type", "")
.split(";", 1)[0]
.strip()
.lower()
)
if content_type != "application/json":
raise ApiError(
415,
"unsupported_media_type",
"Требуется Content-Type: application/json",
)
try:
payload = await request.json()
except (ValueError, UnicodeError):
raise invalid("Некорректный JSON") from None
if (
not isinstance(payload, dict)
or set(payload) != expected_fields
):
raise invalid("Некорректные поля запроса")
return payload
async def current_user(request: Request) -> tuple[dict, str]:
token = parse_bearer_token(
request.headers.get("authorization")
)
if token is None:
raise unauthorized()
token_digest = hash_token(token)
user_id = await store.get_session_user_id(token_digest)
if user_id is None:
raise unauthorized()
user = await get_cached_user(user_id)
if user is None:
raise unauthorized()
return user, token_digest
async def accessible_chat(
raw_chat_id: str,
user_id: UUID,
) -> tuple[UUID, dict]:
chat_id = parse_uuid(raw_chat_id)
chat = await store.get_accessible_chat(chat_id, user_id)
if chat is None:
raise not_found()
return chat_id, chat
def encode_cursor(scope: str, item: dict) -> str:
raw = json.dumps(
{
"scope": scope,
"created_at": utc_text(item["created_at"]),
"id": str(item["id"]),
},
separators=(",", ":"),
).encode("utf-8")
return (
base64.urlsafe_b64encode(raw)
.decode("ascii")
.rstrip("=")
)
def decode_cursor(
cursor: str,
scope: str,
) -> tuple[datetime, UUID]:
if not cursor or len(cursor) > 2048:
raise invalid("Некорректный cursor")
try:
padded = cursor + "=" * (-len(cursor) % 4)
raw = base64.b64decode(
padded,
altchars=b"-_",
validate=True,
)
data = json.loads(raw.decode("utf-8"))
if (
not isinstance(data, dict)
or set(data) != {"scope", "created_at", "id"}
or data["scope"] != scope
):
raise ValueError
timestamp = data["created_at"]
if (
not isinstance(timestamp, str)
or not timestamp.endswith("Z")
or not isinstance(data["id"], str)
):
raise ValueError
created_at = datetime.fromisoformat(
timestamp[:-1] + "+00:00"
)
item_id = UUID(data["id"])
return created_at, item_id
except (
ValueError,
TypeError,
UnicodeError,
binascii.Error,
OverflowError,
):
raise invalid("Некорректный cursor") from None
def pagination(
request: Request,
scope: str,
) -> tuple[int, tuple[datetime, UUID] | None]:
raw_limit = request.query_params.get("limit", "50")
if (
len(raw_limit) > 10
or re.fullmatch(r"[0-9]+", raw_limit) is None
):
raise invalid("Некорректный limit")
limit = int(raw_limit)
if not 1 <= limit <= 100:
raise invalid("Некорректный limit")
raw_cursor = request.query_params.get("cursor")
after = None
if raw_cursor is not None:
after = decode_cursor(raw_cursor, scope)
return limit, after
def page_response(
rows: list[dict],
limit: int,
scope: str,
) -> JSONResponse:
items = rows[:limit]
next_cursor = None
if len(rows) > limit:
next_cursor = encode_cursor(scope, items[-1])
return json_response(
{
"items": items,
"next_cursor": next_cursor,
}
)
@app.get("/health/live")
async def health_live():
return {"status": "ok"}
@app.get("/health/ready")
async def health_ready():
await check_db()
return {"status": "ok"}
@app.post("/api/v1/users")
async def create_user(request: Request):
payload = await read_payload(
request,
{"username", "display_name", "password"},
)
username = payload["username"]
display_name = payload["display_name"]
password = payload["password"]
if (
not isinstance(username, str)
or USERNAME_RE.fullmatch(username) is None
):
raise invalid("Некорректный username")
if not valid_text(display_name, 100):
raise invalid("Некорректное display_name")
if not valid_text(password, 128) or len(password) < 12:
raise invalid("Пароль должен содержать от 12 до 128 символов")
password_digest = await hash_password(password)
user = await store.create_user(
username,
display_name,
password_digest,
)
if user is None:
raise ApiError(
409,
"conflict",
"Username уже занят",
)
return json_response(user, 201)
@app.post("/api/v1/auth/sessions")
async def create_session(request: Request):
credentials = parse_basic_credentials(
request.headers.get("authorization")
)
if credentials is None:
raise unauthorized("Basic")
username, password = credentials
user = await store.get_user_for_login(username)
stored_hash = (
DUMMY_PASSWORD_HASH
if user is None
else user["password_hash"]
)
password_ok = await verify_password(stored_hash, password)
if user is None or not password_ok:
raise unauthorized("Basic")
if await request.body():
raise invalid("Тело запроса при входе не допускается")
token = generate_token()
session = await store.create_session(
user["id"],
hash_token(token),
SESSION_TTL_SECONDS,
)
public_user = {
field: user[field]
for field in ("id", "username", "display_name", "created_at")
}
return json_response(
{
"token": token,
"token_type": "Bearer",
"expires_at": session["expires_at"],
"user": public_user,
},
201,
)
@app.delete("/api/v1/auth/sessions/current")
async def revoke_session(request: Request):
_, token_digest = await current_user(request)
revoked = await store.revoke_session(token_digest)
if not revoked:
raise unauthorized()
return Response(status_code=204)
@app.get("/api/v1/users/me")
async def get_current_user(request: Request):
user, _ = await current_user(request)
return json_response(user)
@app.post("/api/v1/chats")
async def create_chat(request: Request):
user, _ = await current_user(request)
payload = await read_payload(
request,
{"title", "member_ids"},
)
if not valid_text(payload["title"], 100):
raise invalid("Некорректный title")
raw_members = payload["member_ids"]
if (
not isinstance(raw_members, list)
or not 1 <= len(raw_members) <= 100
):
raise invalid("Некорректный member_ids")
member_ids = [parse_uuid(item) for item in raw_members]
if len(set(member_ids)) != len(member_ids):
raise invalid("В member_ids есть дубликаты")
if user["id"] not in member_ids:
raise invalid("Создатель должен входить в member_ids")
try:
chat = await store.create_chat(
payload["title"],
member_ids,
)
except InvalidMembersError:
raise invalid(
"В member_ids есть неизвестный пользователь"
) from None
return json_response(chat, 201)
@app.get("/api/v1/chats")
async def list_chats(request: Request):
user, _ = await current_user(request)
scope = f"chats:{user['id']}"
limit, after = pagination(request, scope)
rows = await store.list_chats(user["id"], limit, after)
return page_response(rows, limit, scope)
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(chat_id: str, request: Request):
user, _ = await current_user(request)
_, chat = await accessible_chat(chat_id, user["id"])
return json_response(chat)
@app.post("/api/v1/chats/{chat_id}/messages")
async def create_message(chat_id: str, request: Request):
user, _ = await current_user(request)
chat_uuid, _ = await accessible_chat(
chat_id,
user["id"],
)
payload = await read_payload(request, {"text"})
if not valid_text(payload["text"], 4000):
raise invalid("Некорректный текст сообщения")
message = await store.create_message(
chat_uuid,
user["id"],
payload["text"],
)
return json_response(message, 201)
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(chat_id: str, request: Request):
user, _ = await current_user(request)
chat_uuid, _ = await accessible_chat(
chat_id,
user["id"],
)
scope = f"messages:{chat_uuid}"
limit, after = pagination(request, scope)
rows = await store.list_messages(
chat_uuid,
limit,
after,
)
return page_response(rows, limit, scope)
+84
View File
@@ -0,0 +1,84 @@
from __future__ import annotations
import hashlib
import os
from pathlib import Path
import psycopg
MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations"
MIGRATION_LOCK_ID = 202602001
def apply_migrations() -> None:
files = sorted(MIGRATIONS_DIR.glob("[0-9]*_*.sql"))
if not files:
raise RuntimeError("Migration files not found")
with psycopg.connect(
host=os.getenv("PGHOST", "postgres"),
port=int(os.getenv("PGPORT", "5432")),
dbname=os.getenv("PGDATABASE", "messenger"),
user=os.getenv("PGUSER", "messenger"),
password=os.environ["PGPASSWORD"],
connect_timeout=5,
options="-c statement_timeout=30000 -c lock_timeout=10000",
) as conn:
conn.execute(
"SELECT pg_advisory_xact_lock(%s)",
(MIGRATION_LOCK_ID,),
)
conn.execute(
"""
CREATE TABLE IF NOT EXISTS schema_migrations (
version TEXT PRIMARY KEY,
checksum TEXT NOT NULL,
applied_at TIMESTAMPTZ NOT NULL
DEFAULT clock_timestamp()
)
"""
)
for path in files:
version = path.name
content = path.read_bytes()
checksum = hashlib.sha256(content).hexdigest()
row = conn.execute(
"""
SELECT checksum
FROM schema_migrations
WHERE version = %s
""",
(version,),
).fetchone()
if row is not None:
if row[0] != checksum:
raise RuntimeError(
f"Applied migration was modified: {version}"
)
print(f"Already applied: {version}", flush=True)
continue
conn.execute(content.decode("utf-8"), prepare=False)
conn.execute(
"""
INSERT INTO schema_migrations (version, checksum)
VALUES (%s, %s)
""",
(version, checksum),
)
print(f"Executed: {version} (pending commit)", flush=True)
print("Migrations committed successfully", flush=True)
if __name__ == "__main__":
apply_migrations()
+273
View File
@@ -0,0 +1,273 @@
from __future__ import annotations
from datetime import datetime
from uuid import UUID, uuid4
from psycopg.errors import ForeignKeyViolation, UniqueViolation
from app.db import pool
class InvalidMembersError(Exception):
pass
class PostgresStore:
async def create_user(
self,
username: str,
display_name: str,
password_hash: str,
) -> dict | None:
try:
async with pool.connection() as conn:
cursor = await conn.execute(
"""
INSERT INTO users (
id, username, display_name, password_hash
)
VALUES (%s, %s, %s, %s)
RETURNING id, username, display_name, created_at
""",
(uuid4(), username, display_name, password_hash),
)
user = await cursor.fetchone()
return user
except UniqueViolation as exc:
if exc.diag.constraint_name == "users_username_unique":
return None
raise
async def get_user(self, user_id: UUID) -> dict | None:
async with pool.connection() as conn:
cursor = await conn.execute(
"""
SELECT id, username, display_name, created_at
FROM users
WHERE id = %s
""",
(user_id,),
)
return await cursor.fetchone()
async def get_user_for_login(self, username: str) -> dict | None:
async with pool.connection() as conn:
cursor = await conn.execute(
"""
SELECT id, username, display_name,
password_hash, created_at
FROM users
WHERE username = %s
""",
(username,),
)
return await cursor.fetchone()
async def create_chat(
self,
title: str,
member_ids: list[UUID],
) -> dict:
chat_id = uuid4()
try:
async with pool.connection() as conn:
cursor = await conn.execute(
"""
INSERT INTO chats (id, title)
VALUES (%s, %s)
RETURNING id, title, created_at
""",
(chat_id, title),
)
chat = await cursor.fetchone()
async with conn.cursor() as cursor:
await cursor.executemany(
"""
INSERT INTO chat_members (chat_id, user_id)
VALUES (%s, %s)
""",
[(chat_id, user_id) for user_id in member_ids],
)
chat["member_ids"] = member_ids
return chat
except ForeignKeyViolation as exc:
raise InvalidMembersError from exc
async def get_accessible_chat(
self,
chat_id: UUID,
user_id: UUID,
) -> dict | None:
async with pool.connection() as conn:
cursor = await conn.execute(
"""
SELECT c.id, c.title, c.created_at,
ARRAY(
SELECT cm.user_id
FROM chat_members AS cm
WHERE cm.chat_id = c.id
ORDER BY cm.user_id
) AS member_ids
FROM chats AS c
WHERE c.id = %s
AND EXISTS (
SELECT 1
FROM chat_members AS access
WHERE access.chat_id = c.id
AND access.user_id = %s
)
""",
(chat_id, user_id),
)
return await cursor.fetchone()
async def list_chats(
self,
user_id: UUID,
limit: int,
after: tuple[datetime, UUID] | None = None,
) -> list[dict]:
params: list[object] = [user_id]
after_sql = ""
if after is not None:
after_sql = "AND (c.created_at, c.id) > (%s, %s)"
params.extend(after)
params.append(limit + 1)
async with pool.connection() as conn:
cursor = await conn.execute(
f"""
SELECT c.id, c.title, c.created_at,
ARRAY(
SELECT cm.user_id
FROM chat_members AS cm
WHERE cm.chat_id = c.id
ORDER BY cm.user_id
) AS member_ids
FROM chats AS c
JOIN chat_members AS access
ON access.chat_id = c.id
WHERE access.user_id = %s
{after_sql}
ORDER BY c.created_at, c.id
LIMIT %s
""",
params,
)
return await cursor.fetchall()
async def create_message(
self,
chat_id: UUID,
sender_id: UUID,
text: str,
) -> dict:
async with pool.connection() as conn:
cursor = await conn.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text)
VALUES (%s, %s, %s, %s)
RETURNING id, chat_id, sender_id, text, created_at
""",
(uuid4(), chat_id, sender_id, text),
)
message = await cursor.fetchone()
return message
async def list_messages(
self,
chat_id: UUID,
limit: int,
after: tuple[datetime, UUID] | None = None,
) -> list[dict]:
params: list[object] = [chat_id]
after_sql = ""
if after is not None:
after_sql = "AND (created_at, id) > (%s, %s)"
params.extend(after)
params.append(limit + 1)
async with pool.connection() as conn:
cursor = await conn.execute(
f"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = %s
{after_sql}
ORDER BY created_at, id
LIMIT %s
""",
params,
)
return await cursor.fetchall()
async def create_session(
self,
user_id: UUID,
token_hash: str,
ttl_seconds: int,
) -> dict:
async with pool.connection() as conn:
cursor = await conn.execute(
"""
INSERT INTO sessions (
token_hash, user_id, created_at, expires_at
)
VALUES (
%s, %s, statement_timestamp(),
statement_timestamp()
+ (%s * INTERVAL '1 second')
)
RETURNING expires_at
""",
(token_hash, user_id, ttl_seconds),
)
session = await cursor.fetchone()
return session
async def get_session_user_id(
self,
token_hash: str,
) -> UUID | None:
async with pool.connection() as conn:
cursor = await conn.execute(
"""
SELECT user_id
FROM sessions
WHERE token_hash = %s
AND expires_at > statement_timestamp()
""",
(token_hash,),
)
row = await cursor.fetchone()
return None if row is None else row["user_id"]
async def revoke_session(self, token_hash: str) -> bool:
async with pool.connection() as conn:
cursor = await conn.execute(
"""
DELETE FROM sessions
WHERE token_hash = %s
AND expires_at > statement_timestamp()
RETURNING token_hash
""",
(token_hash,),
)
row = await cursor.fetchone()
return row is not None
store = PostgresStore()
+84
View File
@@ -0,0 +1,84 @@
name: mtusi2026lab2
services:
postgres:
image: postgres:16.4-bookworm
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test:
- CMD-SHELL
- pg_isready -U "$$POSTGRES_USER" -d "$$POSTGRES_DB"
interval: 5s
timeout: 3s
retries: 10
start_period: 20s
restart: unless-stopped
redis:
image: redis:7.2.5-bookworm
command:
- redis-server
- --appendonly
- "yes"
- --appendfsync
- everysec
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
restart: unless-stopped
migrate:
build:
context: .
image: mtusi-messenger:lab2
command: ["python", "-m", "app.migrate"]
environment:
PGHOST: postgres
PGPORT: "5432"
PGDATABASE: messenger
PGUSER: messenger
PGPASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
depends_on:
postgres:
condition: service_healthy
healthcheck:
disable: true
restart: "no"
api:
build:
context: .
image: mtusi-messenger:lab2
environment:
PGHOST: postgres
PGPORT: "5432"
PGDATABASE: messenger
PGUSER: messenger
PGPASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
REDIS_HOST: redis
REDIS_PORT: "6379"
USER_CACHE_TTL_SECONDS: "${USER_CACHE_TTL_SECONDS:-60}"
SESSION_TTL_SECONDS: "${SESSION_TTL_SECONDS:-3600}"
ports:
- "127.0.0.1:18081:8080"
depends_on:
postgres:
condition: service_healthy
migrate:
condition: service_completed_successfully
restart: unless-stopped
stop_grace_period: 10s
volumes:
postgres_data:
redis_data:
+50
View File
@@ -0,0 +1,50 @@
Pager usage is off.
=== PostgreSQL version ===
version
---------------------------------------------------------------------------------------------------------------------
PostgreSQL 16.4 (Debian 16.4-1.pgdg120+2) on x86_64-pc-linux-gnu, compiled by gcc (Debian 12.2.0-14) 12.2.0, 64-bit
(1 row)
BEGIN
INSERT 0 1
INSERT 0 1
INSERT 0 10000
COMMIT
ANALYZE
=== Fixture size ===
chat_id | message_count | distinct_timestamps
--------------------------------------+---------------+---------------------
0d8d1cf4-bdfa-47a5-a665-3975e1113d78 | 10000 | 1000
(1 row)
=== History index definition ===
indexdef
----------------------------------------------------------------------------------------------------
CREATE INDEX messages_chat_created_id_idx ON public.messages USING btree (chat_id, created_at, id)
(1 row)
=== First page: LIMIT 51 ===
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.29..4.28 rows=51 width=78) (actual time=0.007..0.015 rows=51 loops=1)
Buffers: shared hit=3
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..783.65 rows=10000 width=78) (actual time=0.006..0.011 rows=51 loops=1)
Index Cond: (chat_id = '0d8d1cf4-bdfa-47a5-a665-3975e1113d78'::uuid)
Buffers: shared hit=3
Planning:
Buffers: shared hit=9
Planning Time: 0.067 ms
Execution Time: 0.025 ms
(9 rows)
=== Middle page: keyset cursor, LIMIT 51 ===
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.29..5.66 rows=51 width=78) (actual time=0.005..0.017 rows=51 loops=1)
Buffers: shared hit=9
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..527.86 rows=5010 width=78) (actual time=0.005..0.013 rows=51 loops=1)
Index Cond: ((chat_id = '0d8d1cf4-bdfa-47a5-a665-3975e1113d78'::uuid) AND (ROW(created_at, id) > ROW('2000-01-01 00:00:00.499+00'::timestamp with time zone, 'f53aa6fb-ea52-4332-a211-d239fbf6c885'::uuid)))
Buffers: shared hit=9
Planning Time: 0.052 ms
Execution Time: 0.052 ms
(7 rows)
+11
View File
@@ -0,0 +1,11 @@
test_chat_creation_rollback (__main__.Lab2Checks.test_chat_creation_rollback) ... ok
test_concurrent_username_registration (__main__.Lab2Checks.test_concurrent_username_registration) ... ok
test_logout (__main__.Lab2Checks.test_logout) ... ok
test_unicode_password_with_colons (__main__.Lab2Checks.test_unicode_password_with_colons) ... ok
test_wrong_password (__main__.Lab2Checks.test_wrong_password) ... ok
test_x_user_id_does_not_authenticate_or_change_user (__main__.Lab2Checks.test_x_user_id_does_not_authenticate_or_change_user) ... ok
----------------------------------------------------------------------
Ran 6 tests in 1.523s
OK
+6
View File
@@ -0,0 +1,6 @@
PASS: Redis outage fallback; authenticated request took 0.296s
PASS: PostgreSQL outage fails closed; authenticated request took 3.005s
PASS: existing session recovered after PostgreSQL restart
PASS: short session expired; observed after 2.065s
RESTORED: services running; SESSION_TTL_SECONDS=3600
PASS: dependency outages and short session expiry
+24
View File
@@ -0,0 +1,24 @@
make test-extra && make test-faults
make[1]: Entering directory '/home/polina/projects/mtusi2026lab2'
BASE_URL="http://localhost:18081" python3 tests/lab2_checks.py
test_chat_creation_rollback (__main__.Lab2Checks.test_chat_creation_rollback) ... ok
test_concurrent_username_registration (__main__.Lab2Checks.test_concurrent_username_registration) ... ok
test_logout (__main__.Lab2Checks.test_logout) ... ok
test_unicode_password_with_colons (__main__.Lab2Checks.test_unicode_password_with_colons) ... ok
test_wrong_password (__main__.Lab2Checks.test_wrong_password) ... ok
test_x_user_id_does_not_authenticate_or_change_user (__main__.Lab2Checks.test_x_user_id_does_not_authenticate_or_change_user) ... ok
----------------------------------------------------------------------
Ran 6 tests in 1.384s
OK
make[1]: Leaving directory '/home/polina/projects/mtusi2026lab2'
make[1]: Entering directory '/home/polina/projects/mtusi2026lab2'
BASE_URL="http://localhost:18081" python3 tests/lab2_faults.py
PASS: Redis outage fallback; authenticated request took 0.140s
PASS: PostgreSQL outage fails closed; authenticated request took 3.006s
PASS: existing session recovered after PostgreSQL restart
PASS: short session expired; observed after 2.067s
RESTORED: services running; SESSION_TTL_SECONDS=3600
PASS: dependency outages and short session expiry
make[1]: Leaving directory '/home/polina/projects/mtusi2026lab2'
+3
View File
@@ -0,0 +1,3 @@
/mtusi2026lab2-api-1 started=2026-10-16T14:38:37.177198952Z status=running
/mtusi2026lab2-postgres-1 started=2026-10-16T14:38:30.216555143Z status=running
/mtusi2026lab2-redis-1 started=2026-10-16T14:38:30.148534088Z status=running
+3
View File
@@ -0,0 +1,3 @@
/mtusi2026lab2-api-1 started=2026-10-16T14:33:23.126243575Z status=running
/mtusi2026lab2-postgres-1 started=2026-10-16T11:25:08.609760528Z status=running
/mtusi2026lab2-redis-1 started=2026-10-16T11:25:08.607145864Z status=running
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:18081"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+71
View File
@@ -0,0 +1,71 @@
CREATE TABLE users (
id UUID PRIMARY KEY,
username TEXT NOT NULL,
display_name TEXT NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT users_username_unique UNIQUE (username),
CONSTRAINT users_username_format
CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_length
CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
CREATE TABLE chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT chats_title_length
CHECK (char_length(title) BETWEEN 1 AND 100)
);
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats(id),
user_id UUID NOT NULL REFERENCES users(id),
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_chat_idx
ON chat_members (user_id, chat_id);
CREATE INDEX chats_created_id_idx
ON chats (created_at, id);
CREATE TABLE messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL,
sender_id UUID NOT NULL,
text TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT messages_sender_membership_fk
FOREIGN KEY (chat_id, sender_id)
REFERENCES chat_members (chat_id, user_id),
CONSTRAINT messages_text_length
CHECK (char_length(text) BETWEEN 1 AND 4000)
);
CREATE INDEX messages_chat_created_id_idx
ON messages (chat_id, created_at, id);
CREATE TABLE sessions (
token_hash TEXT PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id),
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(),
expires_at TIMESTAMPTZ NOT NULL,
CONSTRAINT sessions_token_hash_format
CHECK (token_hash ~ '^[0-9a-f]{64}$'),
CONSTRAINT sessions_expiry_order
CHECK (expires_at > created_at)
);
CREATE INDEX sessions_expires_at_idx
ON sessions (expires_at);
CREATE INDEX sessions_user_id_idx
ON sessions (user_id);
+6
View File
@@ -0,0 +1,6 @@
fastapi==0.115.12
uvicorn[standard]==0.34.2
psycopg[binary]==3.2.6
psycopg-pool==3.2.6
redis==5.2.1
argon2-cffi==23.1.0
+94
View File
@@ -0,0 +1,94 @@
\set ON_ERROR_STOP on
\pset pager off
\echo '=== PostgreSQL version ==='
SELECT version();
SELECT id AS user_id
FROM users
ORDER BY created_at, id
LIMIT 1
\gset fixture_
SELECT gen_random_uuid() AS chat_id
\gset fixture_
BEGIN;
INSERT INTO chats (id, title)
VALUES (
:'fixture_chat_id'::uuid,
'EXPLAIN fixture: 10000 messages'
);
INSERT INTO chat_members (chat_id, user_id)
VALUES (
:'fixture_chat_id'::uuid,
:'fixture_user_id'::uuid
);
INSERT INTO messages (
id,
chat_id,
sender_id,
text,
created_at
)
SELECT
gen_random_uuid(),
:'fixture_chat_id'::uuid,
:'fixture_user_id'::uuid,
'Synthetic message ' || n::text,
TIMESTAMPTZ '2000-01-01 00:00:00+00'
+ ((n - 1) / 10) * INTERVAL '1 millisecond'
FROM generate_series(1, 10000) AS series(n);
COMMIT;
ANALYZE messages;
\echo '=== Fixture size ==='
SELECT
chat_id,
count(*) AS message_count,
count(DISTINCT created_at) AS distinct_timestamps
FROM messages
WHERE chat_id = :'fixture_chat_id'::uuid
GROUP BY chat_id;
\echo '=== History index definition ==='
SELECT indexdef
FROM pg_indexes
WHERE schemaname = 'public'
AND tablename = 'messages'
AND indexname = 'messages_chat_created_id_idx';
\echo '=== First page: LIMIT 51 ==='
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = :'fixture_chat_id'::uuid
ORDER BY created_at, id
LIMIT 51;
SELECT
created_at AS created_at,
id AS id
FROM messages
WHERE chat_id = :'fixture_chat_id'::uuid
ORDER BY created_at, id
OFFSET 4999
LIMIT 1
\gset cursor_
\echo '=== Middle page: keyset cursor, LIMIT 51 ==='
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = :'fixture_chat_id'::uuid
AND (created_at, id) > (
:'cursor_created_at'::timestamptz,
:'cursor_id'::uuid
)
ORDER BY created_at, id
LIMIT 51;
+15
View File
@@ -0,0 +1,15 @@
#!/bin/sh
set -eu
PROJECT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)"
cd "$PROJECT_DIR"
docker compose --env-file .env stop --timeout 10 api
docker compose --env-file .env restart --timeout 10 postgres redis
docker compose --env-file .env up \
-d \
--wait \
--wait-timeout 60 \
api redis
+328
View File
@@ -0,0 +1,328 @@
from __future__ import annotations
import base64
import json
import os
import subprocess
import unittest
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from threading import Barrier
from urllib.error import HTTPError
from urllib.request import Request, urlopen
from uuid import uuid4
BASE_URL = os.getenv(
"BASE_URL",
"http://localhost:18081",
).rstrip("/")
PROJECT_DIR = Path(__file__).resolve().parent.parent
PASSWORD = "Synthetic-test-password-123"
class Lab2Checks(unittest.TestCase):
def request(
self,
method,
path,
payload=None,
token=None,
headers=None,
):
request_headers = dict(headers or {})
data = None
if payload is not None:
data = json.dumps(
payload,
ensure_ascii=False,
).encode("utf-8")
request_headers["Content-Type"] = "application/json"
if token is not None:
request_headers["Authorization"] = f"Bearer {token}"
request = Request(
BASE_URL + path,
data=data,
headers=request_headers,
method=method,
)
try:
response = urlopen(request, timeout=20)
except HTTPError as exc:
response = exc
with response:
status = response.code
response_headers = response.headers
raw = response.read()
request_id = response_headers.get("X-Request-Id")
self.assertTrue(request_id, "Missing X-Request-Id")
body = json.loads(raw.decode("utf-8")) if raw else None
if status >= 400:
self.assertIsInstance(body, dict)
self.assertEqual(set(body), {"error"})
self.assertEqual(
set(body["error"]),
{"code", "message", "request_id"},
)
self.assertEqual(
body["error"]["request_id"],
request_id,
)
return status, body, response_headers
def create_user(self, password=PASSWORD):
username = "u_" + uuid4().hex[:20]
status, user, _ = self.request(
"POST",
"/api/v1/users",
{
"username": username,
"display_name": "Тестовый пользователь",
"password": password,
},
)
self.assertEqual(status, 201)
self.assertEqual(
set(user),
{"id", "username", "display_name", "created_at"},
)
return username, user
def login(self, username, password=PASSWORD):
credentials = base64.b64encode(
f"{username}:{password}".encode("utf-8")
).decode("ascii")
return self.request(
"POST",
"/api/v1/auth/sessions",
headers={"Authorization": f"Basic {credentials}"},
)
def create_logged_in_user(self):
username, user = self.create_user()
status, session, _ = self.login(username)
self.assertEqual(status, 201)
return user, session["token"]
def database_counts(self):
result = subprocess.run(
[
"docker",
"compose",
"--env-file",
".env",
"exec",
"-T",
"postgres",
"psql",
"-U",
"messenger",
"-d",
"messenger",
"-At",
"-v",
"ON_ERROR_STOP=1",
"-c",
(
"SELECT "
"(SELECT count(*) FROM chats), "
"(SELECT count(*) FROM chat_members);"
),
],
cwd=PROJECT_DIR,
check=True,
capture_output=True,
text=True,
timeout=15,
)
return tuple(
int(value)
for value in result.stdout.strip().split("|")
)
def test_wrong_password(self):
username, _ = self.create_user()
status, body, headers = self.login(
username,
"Definitely-wrong-password-123",
)
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
self.assertEqual(
headers.get("WWW-Authenticate"),
'Basic realm="messenger", charset="UTF-8"',
)
unknown_username = "missing_" + uuid4().hex[:16]
other_status, other_body, _ = self.login(
unknown_username,
"Definitely-wrong-password-123",
)
self.assertEqual(other_status, 401)
self.assertEqual(
body["error"]["message"],
other_body["error"]["message"],
)
def test_logout(self):
_, token = self.create_logged_in_user()
status, _, _ = self.request(
"GET",
"/api/v1/users/me",
token=token,
)
self.assertEqual(status, 200)
status, body, _ = self.request(
"DELETE",
"/api/v1/auth/sessions/current",
token=token,
)
self.assertEqual(status, 204)
self.assertIsNone(body)
status, _, headers = self.request(
"GET",
"/api/v1/users/me",
token=token,
)
self.assertEqual(status, 401)
self.assertEqual(
headers.get("WWW-Authenticate"),
'Bearer realm="messenger"',
)
status, _, _ = self.request(
"DELETE",
"/api/v1/auth/sessions/current",
token=token,
)
self.assertEqual(status, 401)
def test_x_user_id_does_not_authenticate_or_change_user(self):
first_user, token = self.create_logged_in_user()
_, second_user = self.create_user()
status, _, _ = self.request(
"GET",
"/api/v1/users/me",
headers={"X-User-Id": second_user["id"]},
)
self.assertEqual(status, 401)
status, body, _ = self.request(
"GET",
"/api/v1/users/me",
token=token,
headers={"X-User-Id": second_user["id"]},
)
self.assertEqual(status, 200)
self.assertEqual(body["id"], first_user["id"])
def test_unicode_password_with_colons(self):
password = "Учебный:пароль:длинный-123"
username, _ = self.create_user(password=password)
status, _, _ = self.login(username, password=password)
self.assertEqual(status, 201)
def test_concurrent_username_registration(self):
workers = 4
barrier = Barrier(workers)
username = "race_" + uuid4().hex[:20]
payload = {
"username": username,
"display_name": "Конкурентная регистрация",
"password": PASSWORD,
}
def register(_):
barrier.wait(timeout=10)
status, _, _ = self.request(
"POST",
"/api/v1/users",
payload,
)
return status
with ThreadPoolExecutor(max_workers=workers) as executor:
statuses = list(executor.map(register, range(workers)))
self.assertEqual(
sorted(statuses),
[201, 409, 409, 409],
)
status, _, _ = self.login(username)
self.assertEqual(status, 201)
def test_chat_creation_rollback(self):
user, token = self.create_logged_in_user()
before = self.database_counts()
status, body, _ = self.request(
"POST",
"/api/v1/chats",
{
"title": "Этот чат должен откатиться",
"member_ids": [
user["id"],
str(uuid4()),
],
},
token=token,
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
after = self.database_counts()
self.assertEqual(
before,
after,
"Failed chat creation left database rows",
)
status, _, _ = self.request(
"POST",
"/api/v1/chats",
{
"title": "Создание после rollback",
"member_ids": [user["id"]],
},
token=token,
)
self.assertEqual(status, 201)
if __name__ == "__main__":
unittest.main(verbosity=2)
+325
View File
@@ -0,0 +1,325 @@
from __future__ import annotations
import os
import subprocess
import time
import lab2_checks as checks
PROJECT_DIR = checks.PROJECT_DIR
client = checks.Lab2Checks()
COMPOSE = [
"docker",
"compose",
"--env-file",
".env",
]
def compose(*args, ttl=None):
env = os.environ.copy()
if ttl is not None:
env["SESSION_TTL_SECONDS"] = str(ttl)
result = subprocess.run(
COMPOSE + list(args),
cwd=PROJECT_DIR,
env=env,
capture_output=True,
text=True,
timeout=90,
)
if result.returncode != 0:
raise RuntimeError(
"Compose command failed: "
+ " ".join(args)
+ ". Check docker compose ps -a and service logs."
)
return result.stdout.strip()
def start_storage(service):
compose(
"up",
"-d",
"--no-deps",
"--wait",
"--wait-timeout",
"45",
service,
)
def recreate_api(ttl):
compose(
"up",
"-d",
"--no-deps",
"--force-recreate",
"--wait",
"--wait-timeout",
"45",
"api",
ttl=ttl,
)
def expect_status(
method,
path,
expected,
token=None,
headers=None,
):
started = time.monotonic()
status, body, response_headers = client.request(
method,
path,
token=token,
headers=headers,
)
elapsed = time.monotonic() - started
client.assertEqual(
status,
expected,
f"Unexpected status for {method} {path}",
)
client.assertLess(
elapsed,
10,
f"Request exceeded local test budget: {path}",
)
return body, response_headers, elapsed
def wait_for_working_token(token, timeout=20):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
status, _, _ = client.request(
"GET",
"/api/v1/users/me",
token=token,
)
except OSError:
time.sleep(0.5)
continue
if status == 200:
return
time.sleep(0.5)
raise AssertionError(
"Existing session did not recover after database restart"
)
def main():
original_ttl = int(
compose(
"exec",
"-T",
"api",
"python",
"-c",
(
"import os; "
"print(os.getenv('SESSION_TTL_SECONDS', '3600'))"
),
)
)
client.assertGreaterEqual(
original_ttl,
300,
"Start this scenario with normal SESSION_TTL_SECONDS >= 300",
)
user, token = client.create_logged_in_user()
try:
# Warm the user cache before dependency failures.
expect_status(
"GET",
"/api/v1/users/me",
200,
token=token,
)
expect_status(
"GET",
"/api/v1/users/me",
200,
token=token,
)
compose("stop", "--timeout", "10", "redis")
_, _, elapsed = expect_status(
"GET",
"/api/v1/users/me",
200,
token=token,
)
expect_status(
"GET",
"/api/v1/users/me",
401,
headers={"X-User-Id": str(user["id"])},
)
expect_status("GET", "/health/live", 200)
expect_status("GET", "/health/ready", 200)
print(
f"PASS: Redis outage fallback; "
f"authenticated request took {elapsed:.3f}s",
flush=True,
)
start_storage("redis")
# Refill the cache, then prove it cannot replace session checks.
expect_status(
"GET",
"/api/v1/users/me",
200,
token=token,
)
compose("stop", "--timeout", "10", "postgres")
body, _, elapsed = expect_status(
"GET",
"/api/v1/users/me",
503,
token=token,
)
client.assertEqual(
body["error"]["code"],
"unavailable",
)
expect_status("GET", "/health/live", 200)
expect_status("GET", "/health/ready", 503)
expect_status(
"GET",
"/api/v1/users/me",
401,
headers={"X-User-Id": str(user["id"])},
)
print(
f"PASS: PostgreSQL outage fails closed; "
f"authenticated request took {elapsed:.3f}s",
flush=True,
)
start_storage("postgres")
wait_for_working_token(token)
print(
"PASS: existing session recovered after PostgreSQL restart",
flush=True,
)
recreate_api(ttl=2)
_, short_token = client.create_logged_in_user()
expect_status(
"GET",
"/api/v1/users/me",
200,
token=short_token,
)
started = time.monotonic()
deadline = started + 10
while True:
status, body, headers = client.request(
"GET",
"/api/v1/users/me",
token=short_token,
)
if status == 401:
client.assertEqual(
body["error"]["code"],
"unauthorized",
)
client.assertEqual(
headers.get("WWW-Authenticate"),
'Bearer realm="messenger"',
)
break
client.assertEqual(status, 200)
if time.monotonic() >= deadline:
raise AssertionError(
"Session did not expire with TTL=2"
)
time.sleep(0.25)
print(
f"PASS: short session expired; "
f"observed after {time.monotonic() - started:.3f}s",
flush=True,
)
finally:
restoration_errors = []
for service in ("postgres", "redis"):
try:
start_storage(service)
except Exception as exc:
restoration_errors.append(
f"{service}: {type(exc).__name__}"
)
try:
recreate_api(ttl=original_ttl)
except Exception as exc:
restoration_errors.append(
f"api: {type(exc).__name__}"
)
if restoration_errors:
raise RuntimeError(
"Automatic restoration failed: "
+ ", ".join(restoration_errors)
)
print(
f"RESTORED: services running; "
f"SESSION_TTL_SECONDS={original_ttl}",
flush=True,
)
expect_status("GET", "/health/ready", 200)
print(
"PASS: dependency outages and short session expiry",
flush=True,
)
if __name__ == "__main__":
main()