15 Commits
Author SHA1 Message Date
perevalova a239dd20c9 Merge pull request 'Solution/lab2 implementation' (#1) from solution/lab2-implementation into master
Skeleton contracts / contracts (pull_request) Canceled after 0s
Reviewed-on: perevalova/mtusi2026lab2#1
2026-11-05 14:10:48 +03:00
sinveria 5db7619301 Finalize lab 2 report 2026-11-04 20:08:04 +03:00
sinveria b727fa922a Complete lab 2 PostgreSQL Redis implementation 2026-11-04 20:04:25 +03:00
sinveria 2410960d3c build: run API with PostgreSQL and Redis in Docker Compose 2026-11-04 19:04:20 +03:00
sinveria 527f0e8d74 feat: implement chat messaging and Redis cache 2026-11-04 18:44:55 +03:00
sinveria e0e654dcf5 refactor: connect FastAPI to PostgreSQL services 2026-11-04 17:54:02 +03:00
sinveria c0d8f15d75 feat: add user and authentication API endpoints 2026-11-04 17:52:41 +03:00
sinveria 37bebacc14 feat: update API models for lab2 2026-11-04 17:49:52 +03:00
sinveria 23d16a1cc3 feat: implement authentication and session service 2026-11-04 17:46:51 +03:00
sinveria 85207f3203 feat: implement user registration service 2026-11-04 17:44:27 +03:00
sinveria c4f243672b feat: implement PostgreSQL repositories 2026-11-04 17:38:59 +03:00
sinveria 77875db0d0 feat: add PostgreSQL schema and Docker infrastructure 2026-11-04 17:33:11 +03:00
sinveria e29a0a2bea build: add lab2 backend dependencies 2026-11-04 17:21:29 +03:00
sinveria 288620a107 chore: prepare backend architecture 2026-11-04 17:17:15 +03:00
sinveria 0c19788bd1 chore: import application foundation from lab1 2026-11-04 17:14:54 +03:00
50 changed files with 3246 additions and 25 deletions
+29
View File
@@ -0,0 +1,29 @@
FROM python:3.11.9-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1
WORKDIR /app
RUN groupadd --system app && \
useradd --system --gid app --home-dir /app app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app ./app
COPY migrations ./migrations
COPY alembic.ini .
RUN chown -R app:app /app
USER app
EXPOSE 8080
HEALTHCHECK --interval=15s --timeout=5s --start-period=30s --retries=5 \
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=3)"
CMD ["sh", "-c", "alembic upgrade head && exec uvicorn app.main:app --host 0.0.0.0 --port 8080"]
+4 -1
View File
@@ -4,7 +4,7 @@ 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-persistence-windows
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -24,3 +24,6 @@ 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-persistence-windows:
$(PYTHON) tests/persistence_windows.py --base-url "$(BASE_URL)" $(TLS_ARGS)
+263 -24
View File
@@ -1,37 +1,276 @@
# Отчёт — лабораторная 2
# Отчёт — лабораторная работа № 2
## PostgreSQL, сессии и Redis/Valkey
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор: **Перевалова В.А.**
- Группа: **БПИ2302**
- Целевая оценка: **5**
- Исследовательский трек: **1 — согласованность кэша**
- Репозиторий: `mtusi2026lab2`
- Ветка: `solution/lab2-implementation`
- Commit: **b727fa922ad49f6a2e3f7bfdc29d9f502cdb9ee3**
- Использованные технологии: Python 3.11, FastAPI, SQLAlchemy 2, Alembic, PostgreSQL 16.6, Redis 7.4.2, Docker Compose.
## Запуск из чистого clone
## 1. Назначение и архитектура
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Лабораторная переносит состояние мессенджера из памяти одного процесса в PostgreSQL и добавляет серверные сессии. Redis используется как ускоряющий слой: хранит краткоживущие записи сессий и кэш страниц истории сообщений.
## Архитектура и решения
```text
Клиент
│ HTTP / JSON
▼
FastAPI (контейнер api, порт 8080)
├── SQLAlchemy + Alembic ──► PostgreSQL 16.6
│ └── named volume lab2_postgres_data
└── Redis client ──────────► Redis 7.4.2
└── named volume lab2_redis_data
```
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
**Источник истины — PostgreSQL.** Redis не является единственным местом хранения пользователей, сообщений или сессий. Если Redis недоступен, операции чтения истории выполняются напрямую из PostgreSQL, а аутентификация проверяет запись сессии в PostgreSQL. Кэш Redis ускоряет повторные чтения, но его потеря не должна приводить к потере подтверждённых данных.
## Доказательства критериев
### 1.1. Основные сущности
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Сущность | Назначение и ограничения |
|---|---|
| `User` (`users`) | Пользователь, уникальный `username`, отображаемое имя и хэш пароля |
| `Chat` (`chats`) | Чат с UUID и названием |
| `ChatMember` (`chat_members`) | Связь пользователя с чатом; составной первичный ключ `(chat_id, user_id)` не допускает повторного членства |
| `Message` (`messages`) | Сообщение, внешний ключ на чат и отправителя, текст и время создания |
| `Session` (`sessions`) | Хэш непрозрачного токена, пользователь и время истечения; уникальный индекс по `token_hash` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Пароль не хранится в открытом виде: используется Argon2id. Клиент получает случайный Bearer-токен; в PostgreSQL сохраняется SHA-256-хэш токена. Поэтому утечка таблицы сессий не раскрывает сами токены.
## Эксперименты и отказы
### 1.2. Транзакции и индексы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
- Регистрация выполняет проверку имени и обработку конфликта уникальности на уровне БД.
- Создание чата и добавление участников выполняются одной транзакцией.
- Создание сообщения завершается `COMMIT` до ответа клиенту.
- История запрашивается keyset-пагинацией по паре `(created_at, id)`, а не загрузкой всей истории с последующим смещением.
- Индекс `ix_messages_chat_created_id (chat_id, created_at, id)` соответствует фильтру по чату и сортировке истории.
- SQLAlchemy использует параметризованные выражения ORM; пул соединений ограничен `pool_size=5`, `max_overflow=10`, `pool_timeout=30`, включён `pool_pre_ping`.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
## 2. Аутентификация и сессии
## Ограничения и следующие шаги
1. Регистрация: `POST /api/v1/users`, пароль обязателен.
2. Вход: `POST /api/v1/auth/sessions` с HTTP Basic. Сервер проверяет Argon2id-хэш, создаёт случайный токен и сохраняет его хэш и `expires_at` в PostgreSQL.
3. Защищённые методы используют `Authorization: Bearer <token>`.
4. При каждом запросе сервер проверяет сессию в PostgreSQL. Redis-копия с TTL используется как кэш, но не заменяет проверку срока действия и отзыва в БД.
5. Выход: `DELETE /api/v1/auth/sessions/current`; запись удаляется из PostgreSQL и Redis.
6. `X-User-Id` не используется для установления личности клиента.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Redis недоступен — приложение продолжает проверять сессию по PostgreSQL. PostgreSQL недоступен — защищённый запрос не должен считаться аутентифицированным.
## 3. Кэш истории и исследовательский трек 1
### 3.1. Гипотеза
Кэширование страниц истории сообщений в Redis позволяет повторно использовать ранее полученные данные и уменьшать количество обращений к PostgreSQL. Версионирование кэша обеспечивает актуальность истории после добавления новых сообщений. Распределённая блокировка `SET NX EX` предназначена для ограничения одновременного заполнения одного и того же кэш-ключа.
### 3.2. Реализация
- Ключ страницы истории учитывает идентификатор чата, версию истории, размер страницы и курсор.
- При добавлении сообщения версия кэша чата увеличивается.
- Для защиты от одновременного заполнения кэша используется Redis-блокировка `SET NX EX`.
- При недоступности Redis чтение истории может выполняться непосредственно из PostgreSQL.
- PostgreSQL остаётся основным источником достоверных данных.
- Время хранения кэшированных страниц ограничивается TTL.
### 3.3. Методика исследования
Исследование выполнялось на локальном стенде Docker Compose.
Были проведены следующие проверки:
1. Первое чтение истории тестового чата.
2. 30 последовательных повторных чтений.
3. Добавление нового сообщения и проверка его немедленной доступности через API (read-after-write).
4. Перезапуск Redis командой `docker compose restart redis`.
5. Повторение чтения истории после перезапуска Redis.
Дополнительно была выполнена проверка плана SQL-запроса истории на базе, содержащей 10 009 сообщений.
### 3.4. Результаты исследования кэширования
| Показатель | До перезапуска Redis | После перезапуска Redis |
|---|---:|---:|
| Первое чтение, мс | 15,612 | 52,287 |
| Количество повторных чтений | 30 | 30 |
| Среднее время повторного чтения, мс | 27,055 | 26,478 |
| Медиана повторного чтения, мс | 32,556 | 29,496 |
| Минимальное время повторного чтения, мс | 9,369 | 13,785 |
| Максимальное время повторного чтения, мс | 47,914 | 46,404 |
| Read-after-write | PASS | PASS |
После перезапуска Redis приложение продолжило обслуживать запросы. Новое сообщение успешно обнаруживалось после записи и последующего чтения истории.
Полученные значения показывают, что повторные запросы выполнялись с сопоставимым временем. При этом результаты первого чтения различались между запусками, поэтому на основании двух серий нельзя утверждать о стабильном ускорении всех повторных запросов.
### 3.5. Проверка индекса истории
Для проверки использовался запрос с `EXPLAIN (ANALYZE, BUFFERS)` на таблице `messages`, содержащей 10 009 записей.
Полученный план выполнения основного запроса истории:
- Используемый индекс: `ix_messages_chat_created_id`.
- Тип доступа: `Index Scan`.
- Количество возвращённых строк: 51.
- Время выполнения основного запроса: 1,580 мс.
- Использовано 140 shared buffer hits для всего плана запроса.
В плане также присутствовал `Seq Scan` при поиске чата с наибольшим количеством сообщений. Это отдельная агрегирующая операция, а основной запрос получения истории использовал индекс `ix_messages_chat_created_id`.
### 3.6. Дополнительный нагрузочный тест
Для проверки записи сообщений выполнен нагрузочный тест продолжительностью около 10 секунд с конкурентностью 4.
| Показатель | Результат |
|---|---:|
| Успешные запросы | 674 |
| Ошибочные запросы | 0 |
| Доля ошибок | 0 % |
| Пропускная способность | 64,002 запроса/с |
| p50 | 62 мс |
| p95 | 94 мс |
| p99 | 110 мс |
| Фактическая продолжительность | 10,531 с |
Нагрузочный тест использовал закрытый цикл запросов (closed-loop), поэтому результат характеризует только данный локальный профиль нагрузки и не является оценкой предельной производительности системы.
### 3.7. Выводы и ограничения
Проверки подтвердили использование индекса для получения истории сообщений, сохранение актуальности данных после записи и работоспособность приложения после перезапуска Redis. Дополнительно выполнен отдельный конкурентный эксперимент, проверяющий поведение кэша при одновременном чтении одной и той же страницы истории.
В эксперименте участвовали 12 параллельных запросов при холодном кэше и 12 параллельных запросов при прогретом кэше. На время эксперимента в PostgreSQL включалось логирование всех SQL-запросов (`log_min_duration_statement = 0`); после завершения исходная настройка восстанавливалась. В журнале подсчитывались только запросы `SELECT`, содержащие `FROM messages`.
| Показатель | Холодный кэш | Прогретый кэш |
|---|---:|---:|
| Количество параллельных запросов | 12 | 12 |
| Время выполнения группы, мс | 172 | 110 |
| SQL `SELECT ... FROM messages` | 0 | 0 |
| Результат | PASS | PASS |
В холодной группе конкурентные запросы не привели к выполнению запросов чтения таблицы `messages` в PostgreSQL: заполнение страницы было согласовано механизмом Redis-блокировки. В прогретой группе обращения к PostgreSQL за сообщениями также отсутствовали, поскольку данные были получены из кэша. Результат подтверждает работу реализованной защиты от cache stampede для проверенного сценария и профиля нагрузки.
Измерения времени группы запросов характеризуют только локальный стенд и конкретный запуск. Они не являются универсальной оценкой производительности или гарантией такого же результата при другой нагрузке и конфигурации.
## 4. Инфраструктура и запуск
### Требования
- Docker Desktop с Docker Compose plugin.
- Python 3.11 для запуска тестовых скриптов на Windows.
- PowerShell.
- Свободные локальные порты 8080, 5433 и 6379.
### Первый запуск (PowerShell из корня репозитория)
```powershell
Copy-Item .env.example .env
docker compose config --quiet
docker compose up -d --build
docker compose ps
Invoke-RestMethod http://127.0.0.1:8080/health/ready
```
Миграция `alembic upgrade head` запускается командой контейнера API при старте. Swagger UI: `http://127.0.0.1:8080/docs`.
### Проверки
```powershell
python scripts/check_contract.py
python scripts/validate_openapi.py
python tests/smoke.py --base-url http://127.0.0.1:8080
python tests/persistence_windows.py --base-url http://127.0.0.1:8080
python tests/grade5_checks.py --base-url http://127.0.0.1:8080 --only all
```
`tests/persistence_windows.py` — Windows-совместимый сценарий: создаёт синтетических пользователей, чат, сообщение и сессию; перезапускает API, PostgreSQL и Redis через `scripts/restart.ps1`; затем проверяет прежним токеном доступ к API и наличие прежнего сообщения.
### Безопасный перезапуск и остановка
```powershell
docker compose restart
docker compose down
```
`docker compose down` не удаляет именованные volumes. Не используйте `docker compose down -v`, `docker volume rm` или `docker system prune --volumes`, если нужно сохранить результаты лабораторной.
## 5. Сопоставление критериев лабораторной работы
| Критерий | Реализация и подтверждение | Статус |
|---|---|---|
| Хранение пользователей, чатов, участников, сообщений и сессий в PostgreSQL | SQLAlchemy-модели в `app/db/models.py` | Реализовано |
| Первичные и внешние ключи, уникальные ограничения | Модели SQLAlchemy и начальная миграция Alembic | Реализовано |
| Миграции базы данных | `migrations/versions/21ad89656327_create_initial_database_schema.py`; миграция автоматически применяется при запуске API | Проверено запуском приложения |
| Аутентификация HTTP Basic и Bearer | `app/services/auth_service.py`, `app/api/auth.py`, `app/api/deps.py` | Реализовано; API smoke-тест пройден |
| Хэширование паролей | Argon2id в `app/services/user_service.py` | Реализовано |
| Создание, истечение срока действия и отзыв сессий | PostgreSQL как источник истины, Redis как дополнительный слой с TTL | Реализовано |
| Использование Redis для сессий и кэширования истории | AuthService и MessageService | Реализовано |
| Обработка недоступности Redis | При остановке Redis чтение истории и Bearer-аутентификация продолжили работать через PostgreSQL; `grade5_checks.py --only redis` | Проверено: PASS |
| Ограничение пула соединений PostgreSQL | `app/db/session.py`: `pool_size=5`, `max_overflow=10`, `pool_timeout=30`, `pool_pre_ping=True` | Реализовано |
| Keyset-пагинация истории сообщений | Репозиторий сообщений, сортировка и курсор по `(created_at, id)` | Реализовано |
| Индекс истории сообщений | `ix_messages_chat_created_id`; подтверждён через `EXPLAIN (ANALYZE, BUFFERS)` на 10 009 сообщениях | Проверено: Index Scan |
| Docker Compose и постоянное хранение данных | `compose.yaml`, именованные volumes PostgreSQL и Redis | Проверено |
| Готовность инфраструктуры | `docker compose ps`: API, PostgreSQL и Redis имеют статус `healthy` | PASS |
| Проверка контракта и структуры проекта | `python scripts/check_contract.py` | PASS |
| Проверка OpenAPI 3.1 и JSON Schema | `python scripts/validate_openapi.py` | PASS |
| Проверка публичного API | `python tests/smoke.py --base-url http://127.0.0.1:8080` | PASS |
| Сохранение данных и действующей сессии после перезапуска | `python tests/persistence_windows.py --base-url http://127.0.0.1:8080` | PASS |
| Нагрузочная проверка записи сообщений | `python tests/load.py`: 674 успешных запроса, 0 ошибок, 64,002 запроса/с | PASS |
| Проверка актуальности кэша после записи (read-after-write) | `python tests/cache_research.py`, выполнено до и после перезапуска Redis | PASS |
| Восстановление работы кэша после перезапуска Redis | Перезапуск Redis и повторное чтение истории | PASS |
| Конкурентная регистрация одинакового username | 12 одновременных запросов: 1 успешное создание, 11 конфликтов; в БД осталась ровно 1 запись; `grade5_checks.py` | Проверено: PASS |
| Атомарность создания чата и откат транзакции | Принудительно вызвана ошибка добавления участника; после rollback запись чата не осталась в БД; `grade5_checks.py` | Проверено: PASS |
| Истечение короткой сессии по TTL | При TTL 3 секунды истёкшая сессия была отклонена; `grade5_checks.py` | Проверено: PASS |
| Поведение при недоступности PostgreSQL | При остановке PostgreSQL `/health/ready` вернул 503, защищённый запрос завершился отказом; `grade5_checks.py` | Проверено: PASS |
| Исследовательский трек 1: согласованность кэша | Проверены read-after-write до и после перезапуска Redis, конкурентное заполнение страницы и отсутствие SQL-чтений `messages` в холодной и тёплой группах | Проверено: PASS |
| Исследовательский трек 1: сравнение SQL-запросов и защита от cache stampede | 12 холодных и 12 тёплых параллельных запросов; 0 `SELECT ... FROM messages` в каждой группе; `evidence/grade5-checks.txt` и `evidence/cache-stampede.json` | Проверено: PASS |
### Общий вывод по критериям
Основные функциональные компоненты лабораторной работы реализованы и запущены в Docker Compose. Проверены публичный API, OpenAPI-контракт, сохранение данных PostgreSQL и действующей Bearer-сессии после перезапуска сервисов, использование индекса истории на 10 009 сообщениях, нагрузочная запись сообщений и актуальность данных после записи.
Дополнительно успешно выполнены негативные и конкурентные сценарии: конкурентная регистрация, откат транзакции создания чата, истечение короткой сессии, отказ Redis, отказ PostgreSQL и конкурентные холодные/тёплые чтения кэша. Все шесть сценариев комплексного набора `tests/grade5_checks.py --only all` завершились с результатом PASS. В эксперименте cache stampede зафиксировано 0 SQL-запросов `SELECT ... FROM messages` как для 12 параллельных холодных запросов, так и для 12 параллельных запросов к прогретому кэшу.
Таким образом, функциональность, отказоустойчивое поведение в проверенных сценариях и выбранный исследовательский трек подтверждены воспроизводимыми тестами. Результаты относятся к локальному стенду Docker Compose и не являются гарантией производительности в промышленной среде.
## 6. Доказательства
В каталоге `evidence/` сохранены результаты экспериментов:
- `load-10s.json` — результаты нагрузочного теста записи сообщений.
- `cache-research.json` — результаты исследования чтения истории до и после перезапуска Redis.
- `cache-stampede.json` — результаты отдельного эксперимента конкурентного чтения кэша.
- `grade5-checks.txt` — полный вывод комплексного набора из шести проверок.
- `check-contract.txt` — результат проверки структуры и контракта.
- `openapi-validation.txt` — результат проверки OpenAPI 3.1 и JSON Schema.
- `smoke.txt` — результат проверки публичного API.
- `persistence-windows.txt` — результат проверки сохранения данных и сессии после перезапуска.
Дополнительно выполнены проверки:
- `python scripts/check_contract.py` — PASS.
- `python scripts/validate_openapi.py` — PASS.
- `python tests/smoke.py --base-url http://127.0.0.1:8080` — PASS.
- `python tests/persistence_windows.py --base-url http://127.0.0.1:8080` — PASS.
- `docker compose ps` — все три контейнера healthy.
- `docker compose exec redis redis-cli ping` — PONG.
- `EXPLAIN (ANALYZE, BUFFERS)` — основной запрос истории использует индекс.
- `docker-compose-ps.txt` — состояние контейнеров Docker Compose.
- `grade5-checks.txt` — полный протокол: все шесть проверок завершились с результатом PASS.
Комплексная проверка запускается командой:
```powershell
python tests/grade5_checks.py --base-url http://127.0.0.1:8080 --only all
```
Результат полного запуска сохранён в `evidence/grade5-checks.txt`.
## 7. Ограничения
- Redis — ускоряющий слой, PostgreSQL — долговременный источник истины.
- Локальный Compose стенд не обеспечивает отказоустойчивость при потере самого Docker host.
- Проверка восстановления после рестарта не равнозначна резервному копированию; отдельная процедура backup/restore не входит в выбранный трек.
- Результаты нагрузочного и кэш-экспериментов относятся к локальному стенду, конкретной конфигурации и профилю запросов; их нельзя напрямую переносить на промышленную нагрузку.
- Время холодной и тёплой групп в эксперименте cache stampede не является универсальным показателем ускорения. Основным подтверждённым результатом этого эксперимента является отсутствие SQL-чтений таблицы `messages` в обеих группах.
- Локальный стенд не проверяет отказоустойчивость при потере Docker host и не заменяет резервное копирование и восстановление из backup.
+117
View File
@@ -0,0 +1,117 @@
# A generic, single database configuration.
[alembic]
# path to migration scripts
# Use forward slashes (/) also on windows to provide an os agnostic path
script_location = migrations
# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
# Uncomment the line below if you want the files to be prepended with date and time
# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
# for all available tokens
# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
# sys.path path, will be prepended to sys.path if present.
# defaults to the current working directory.
prepend_sys_path = .
# timezone to use when rendering the date within the migration file
# as well as the filename.
# If specified, requires the python>=3.9 or backports.zoneinfo library.
# Any required deps can installed by adding `alembic[tz]` to the pip requirements
# string value is passed to ZoneInfo()
# leave blank for localtime
# timezone =
# max length of characters to apply to the "slug" field
# truncate_slug_length = 40
# set to 'true' to run the environment during
# the 'revision' command, regardless of autogenerate
# revision_environment = false
# set to 'true' to allow .pyc and .pyo files without
# a source .py file to be detected as revisions in the
# versions/ directory
# sourceless = false
# version location specification; This defaults
# to migrations/versions. When using multiple version
# directories, initial revisions must be specified with --version-path.
# The path separator used here should be the separator specified by "version_path_separator" below.
# version_locations = %(here)s/bar:%(here)s/bat:migrations/versions
# version path separator; As mentioned above, this is the character used to split
# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
# Valid values for version_path_separator are:
#
# version_path_separator = :
# version_path_separator = ;
# version_path_separator = space
# version_path_separator = newline
version_path_separator = os # Use os.pathsep. Default configuration used for new projects.
# set to 'true' to search source files recursively
# in each "version_locations" directory
# new in Alembic version 1.10
# recursive_version_locations = false
# the output encoding used when revision files
# are written from script.py.mako
# output_encoding = utf-8
sqlalchemy.url = driver://user:pass@localhost/dbname
[post_write_hooks]
# post_write_hooks defines scripts or Python functions that are run
# on newly generated revision scripts. See the documentation for further
# detail and examples
# format using "black" - use the console_scripts runner, against the "black" entrypoint
# hooks = black
# black.type = console_scripts
# black.entrypoint = black
# black.options = -l 79 REVISION_SCRIPT_FILENAME
# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
# hooks = ruff
# ruff.type = exec
# ruff.executable = %(here)s/.venv/bin/ruff
# ruff.options = --fix REVISION_SCRIPT_FILENAME
# Logging configuration
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARNING
handlers = console
qualname =
[logger_sqlalchemy]
level = WARNING
handlers =
qualname = sqlalchemy.engine
[logger_alembic]
level = INFO
handlers =
qualname = alembic
[handler_console]
class = StreamHandler
args = (sys.stderr,)
level = NOTSET
formatter = generic
[formatter_generic]
format = %(levelname)-5.5s [%(name)s] %(message)s
datefmt = %H:%M:%S
View File
View File
+96
View File
@@ -0,0 +1,96 @@
from datetime import timezone
from fastapi import APIRouter, Depends, Header, HTTPException, status
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from sqlalchemy.orm import Session
from app.api.deps import get_db
from app.api.users import user_to_response
from app.services.auth_service import (
AuthService,
InvalidCredentialsError,
InvalidSessionError,
)
router = APIRouter(prefix="/api/v1/auth", tags=["Authentication"])
basic_security = HTTPBasic(auto_error=False)
@router.post("/sessions", status_code=status.HTTP_201_CREATED)
def create_session(
credentials: HTTPBasicCredentials = Depends(basic_security),
db: Session = Depends(get_db),
):
if credentials is None:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Basic authentication required",
headers={
"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'
},
)
try:
result = AuthService(db).create_session(
username=credentials.username,
password=credentials.password,
)
expires_at = result["expires_at"]
if expires_at.tzinfo is None:
expires_at = expires_at.replace(tzinfo=timezone.utc)
else:
expires_at = expires_at.astimezone(timezone.utc)
return {
"token": result["token"],
"token_type": result["token_type"],
"expires_at": expires_at.isoformat(
timespec="microseconds"
).replace("+00:00", "Z"),
"user": user_to_response(result["user"]),
}
except InvalidCredentialsError:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid username or password",
headers={
"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'
},
) from None
@router.delete("/sessions/current", status_code=status.HTTP_204_NO_CONTENT)
def delete_current_session(
authorization: str | None = Header(default=None),
db: Session = Depends(get_db),
):
if not authorization or not authorization.startswith("Bearer "):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Bearer token required",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'},
)
token = authorization[7:].strip()
if not token:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Bearer token required",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'},
)
try:
AuthService(db).delete_session(token)
except InvalidSessionError:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid or expired session",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'},
) from None
+90
View File
@@ -0,0 +1,90 @@
import uuid
from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy.orm import Session
from app.api.deps import get_db, get_current_user
from app.db.models import User as UserModel
from app.models import Chat as ChatResponse, CreateChat
from app.services.chat_service import (
ChatService,
ChatNotFoundError,
InvalidChatDataError,
)
router = APIRouter(prefix="/api/v1/chats", tags=["Chats"])
def chat_to_response(chat) -> ChatResponse:
return ChatResponse(
id=str(chat.id),
title=chat.title,
member_ids=[str(member.user_id) for member in chat.members],
created_at=chat.created_at,
)
@router.post("", response_model=ChatResponse, status_code=status.HTTP_201_CREATED)
def create_chat(
body: CreateChat,
db: Session = Depends(get_db),
user: UserModel = Depends(get_current_user),
):
try:
chat = ChatService(db).create_chat(
title=body.title,
member_ids=body.member_ids,
creator_id=user.id,
)
return chat_to_response(chat)
except InvalidChatDataError as exc:
raise HTTPException(
status_code=400,
detail=str(exc),
) from None
@router.get("")
def list_chats(
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = None,
db: Session = Depends(get_db),
user: UserModel = Depends(get_current_user),
):
if cursor is not None:
raise HTTPException(
status_code=400,
detail="Chat cursor pagination is not implemented yet",
)
chats = ChatService(db).list_chats(user.id)
chats = chats[:limit]
return {
"items": [chat_to_response(chat) for chat in chats],
"next_cursor": None,
}
@router.get("/{chat_id}", response_model=ChatResponse)
def get_chat(
chat_id: str,
db: Session = Depends(get_db),
user: UserModel = Depends(get_current_user),
):
try:
parsed_id = uuid.UUID(chat_id)
except ValueError:
raise HTTPException(status_code=400, detail="Invalid chat UUID") from None
try:
chat = ChatService(db).get_chat(parsed_id, user.id)
return chat_to_response(chat)
except ChatNotFoundError:
raise HTTPException(
status_code=404,
detail="Chat not found",
) from None
+40
View File
@@ -0,0 +1,40 @@
from fastapi import Depends, HTTPException, status
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
from sqlalchemy.orm import Session
from app.db.session import SessionLocal
from app.services.auth_service import AuthService, InvalidSessionError
bearer_scheme = HTTPBearer(auto_error=False)
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
def get_current_user(
credentials: HTTPAuthorizationCredentials | None = Depends(bearer_scheme),
db: Session = Depends(get_db),
):
if credentials is None or credentials.scheme.lower() != "bearer":
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Bearer token required",
headers={"WWW-Authenticate": "Bearer"},
)
try:
user = AuthService(db).authenticate(credentials.credentials)
return user
except InvalidSessionError:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid or expired token",
headers={"WWW-Authenticate": "Bearer"},
) from None
+102
View File
@@ -0,0 +1,102 @@
import uuid
from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy.orm import Session
from app.api.deps import get_db, get_current_user
from app.db.models import User as UserModel
from app.models import CreateMessage, Message as MessageResponse
from app.services.message_service import (
MessageService,
MessageNotFoundError,
InvalidMessageDataError,
)
router = APIRouter(prefix="/api/v1/chats/{chat_id}/messages", tags=["Messages"])
def message_to_response(message) -> MessageResponse:
return MessageResponse(
id=str(message.id),
chat_id=str(message.chat_id),
sender_id=str(message.sender_id),
text=message.text,
created_at=message.created_at,
)
def parse_chat_id(chat_id: str) -> uuid.UUID:
try:
return uuid.UUID(chat_id)
except ValueError:
raise HTTPException(
status_code=400,
detail="Invalid chat UUID",
) from None
@router.post("", response_model=MessageResponse, status_code=status.HTTP_201_CREATED)
def create_message(
chat_id: str,
body: CreateMessage,
db: Session = Depends(get_db),
user: UserModel = Depends(get_current_user),
):
parsed_id = parse_chat_id(chat_id)
try:
message = MessageService(db).create_message(
chat_id=parsed_id,
sender_id=user.id,
text=body.text,
)
return message_to_response(message)
except MessageNotFoundError:
raise HTTPException(
status_code=404,
detail="Chat not found",
) from None
except InvalidMessageDataError as exc:
raise HTTPException(
status_code=400,
detail=str(exc),
) from None
@router.get("")
def list_messages(
chat_id: str,
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = None,
db: Session = Depends(get_db),
user: UserModel = Depends(get_current_user),
):
parsed_id = parse_chat_id(chat_id)
try:
messages, next_cursor = MessageService(db).get_history(
chat_id=parsed_id,
user_id=user.id,
limit=limit,
cursor=cursor,
)
return {
"items": [message_to_response(item) for item in messages],
"next_cursor": next_cursor,
}
except MessageNotFoundError:
raise HTTPException(
status_code=404,
detail="Chat not found",
) from None
except InvalidMessageDataError as exc:
raise HTTPException(
status_code=400,
detail=str(exc),
) from None
+55
View File
@@ -0,0 +1,55 @@
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session
from app.api.deps import get_db, get_current_user
from app.db.models import User as UserModel
from app.models import CreateUser, User
from app.services.user_service import (
UserService,
UsernameAlreadyExistsError,
)
router = APIRouter(prefix="/api/v1/users", tags=["Users"])
def user_to_response(user: UserModel) -> User:
return User(
id=str(user.id),
username=user.username,
display_name=user.display_name,
created_at=user.created_at,
)
@router.post("", response_model=User, status_code=status.HTTP_201_CREATED)
def register_user(
body: CreateUser,
db: Session = Depends(get_db),
):
try:
user = UserService(db).register(
username=body.username,
display_name=body.display_name,
password=body.password,
)
return user_to_response(user)
except UsernameAlreadyExistsError:
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail="Username already exists",
) from None
except ValueError as exc:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail=str(exc),
) from None
@router.get("/me", response_model=User)
def get_me(
current_user: UserModel = Depends(get_current_user),
):
return user_to_response(current_user)
View File
+23
View File
@@ -0,0 +1,23 @@
from pydantic_settings import BaseSettings, SettingsConfigDict
class Settings(BaseSettings):
app_name: str = "Messenger API"
app_env: str = "lab"
database_url: str = (
"postgresql+psycopg://messenger:messenger@localhost:5432/messenger"
)
session_ttl_seconds: int = 3600
cache_url: str = "redis://localhost:6379/0"
message_cache_ttl_seconds: int = 60
model_config = SettingsConfigDict(
env_file=".env",
env_file_encoding="utf-8",
extra="ignore",
)
settings = Settings()
View File
+5
View File
@@ -0,0 +1,5 @@
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
pass
+184
View File
@@ -0,0 +1,184 @@
import uuid
from datetime import datetime, timezone
from sqlalchemy import (
DateTime,
ForeignKey,
Index,
String,
Text,
UniqueConstraint,
)
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.orm import Mapped, mapped_column, relationship
from app.db.base import Base
def utc_now() -> datetime:
return datetime.now(timezone.utc)
class User(Base):
__tablename__ = "users"
id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
)
username: Mapped[str] = mapped_column(
String(32),
unique=True,
nullable=False,
index=True,
)
display_name: Mapped[str] = mapped_column(
String(100),
nullable=False,
)
password_hash: Mapped[str] = mapped_column(
String(255),
nullable=False,
)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True),
default=utc_now,
nullable=False,
)
memberships: Mapped[list["ChatMember"]] = relationship(
back_populates="user",
cascade="all, delete-orphan",
)
messages: Mapped[list["Message"]] = relationship(
back_populates="sender",
)
class Chat(Base):
__tablename__ = "chats"
id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
)
title: Mapped[str] = mapped_column(
String(100),
nullable=False,
)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True),
default=utc_now,
nullable=False,
)
members: Mapped[list["ChatMember"]] = relationship(
back_populates="chat",
cascade="all, delete-orphan",
)
messages: Mapped[list["Message"]] = relationship(
back_populates="chat",
cascade="all, delete-orphan",
)
class ChatMember(Base):
__tablename__ = "chat_members"
chat_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("chats.id", ondelete="CASCADE"),
primary_key=True,
)
user_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("users.id", ondelete="CASCADE"),
primary_key=True,
)
chat: Mapped["Chat"] = relationship(
back_populates="members",
)
user: Mapped["User"] = relationship(
back_populates="memberships",
)
class Message(Base):
__tablename__ = "messages"
id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
)
chat_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("chats.id", ondelete="CASCADE"),
nullable=False,
)
sender_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("users.id"),
nullable=False,
)
text: Mapped[str] = mapped_column(
Text,
nullable=False,
)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True),
default=utc_now,
nullable=False,
)
chat: Mapped["Chat"] = relationship(
back_populates="messages",
)
sender: Mapped["User"] = relationship(
back_populates="messages",
)
__table_args__ = (
Index(
"ix_messages_chat_created_id",
"chat_id",
"created_at",
"id",
),
)
class Session(Base):
__tablename__ = "sessions"
id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
)
token_hash: Mapped[str] = mapped_column(
String(64),
unique=True,
nullable=False,
index=True,
)
user_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("users.id", ondelete="CASCADE"),
nullable=False,
)
expires_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True),
nullable=False,
)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True),
default=utc_now,
nullable=False,
)
user: Mapped["User"] = relationship()
+19
View File
@@ -0,0 +1,19 @@
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from app.core.config import settings
engine = create_engine(
settings.database_url,
pool_pre_ping=True,
pool_size=5,
max_overflow=10,
pool_timeout=30,
)
SessionLocal = sessionmaker(
bind=engine,
autoflush=False,
autocommit=False,
)
+149
View File
@@ -0,0 +1,149 @@
import logging
import uuid
from contextlib import asynccontextmanager
from fastapi import FastAPI, HTTPException, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from sqlalchemy import text
from sqlalchemy.exc import SQLAlchemyError
from app.api.auth import router as auth_router
from app.api.users import router as users_router
from app.api.chats import router as chats_router
from app.api.messages import router as messages_router
from app.core.config import settings
from app.db.session import engine
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(name)s %(message)s",
)
logger = logging.getLogger(__name__)
@asynccontextmanager
async def lifespan(app: FastAPI):
logger.info("Application startup")
yield
engine.dispose()
logger.info("Application shutdown")
app = FastAPI(
title="Messenger API",
version="1.2.0",
lifespan=lifespan,
)
app.include_router(users_router)
app.include_router(auth_router)
app.include_router(chats_router)
app.include_router(messages_router)
@app.middleware("http")
async def add_request_id(request: Request, call_next):
request_id = str(uuid.uuid4())
request.state.request_id = request_id
try:
response = await call_next(request)
except Exception:
logger.exception(
"Unhandled request error; request_id=%s",
request_id,
)
response = JSONResponse(
status_code=500,
content={
"error": {
"code": "internal_error",
"message": "Unexpected error",
"request_id": request_id,
}
},
)
response.headers["X-Request-Id"] = request_id
return response
@app.exception_handler(HTTPException)
async def http_exception_handler(request: Request, exc: HTTPException):
request_id = request.state.request_id
error_code_map = {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
500: "internal_error",
503: "unavailable",
}
headers = dict(exc.headers or {})
headers["X-Request-Id"] = request_id
return JSONResponse(
status_code=exc.status_code,
content={
"error": {
"code": error_code_map.get(
exc.status_code,
"internal_error",
),
"message": (
exc.detail
if isinstance(exc.detail, str)
else "Request failed"
),
"request_id": request_id,
}
},
headers=headers,
)
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(
request: Request,
exc: RequestValidationError,
):
request_id = request.state.request_id
return JSONResponse(
status_code=400,
content={
"error": {
"code": "invalid_request",
"message": "Validation error",
"request_id": request_id,
}
},
headers={"X-Request-Id": request_id},
)
@app.get("/health/live")
def liveness():
return {"status": "ok"}
@app.get("/health/ready")
def readiness():
try:
with engine.connect() as connection:
connection.execute(text("SELECT 1"))
return {"status": "ok"}
except SQLAlchemyError:
logger.exception("PostgreSQL readiness check failed")
raise HTTPException(
status_code=503,
detail="Database unavailable",
) from None
+110
View File
@@ -0,0 +1,110 @@
from datetime import datetime, timezone
from typing import List, Optional
from pydantic import BaseModel, ConfigDict, Field, field_validator
class BaseConfig(BaseModel):
model_config = ConfigDict(
from_attributes=True,
json_encoders={
datetime: lambda value: (
value.astimezone(timezone.utc)
.isoformat(timespec="microseconds")
.replace("+00:00", "Z")
)
},
)
class CreateUser(BaseConfig):
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 validate_display_name(cls, value: str) -> str:
value = value.strip()
if not value:
raise ValueError("display_name must not be blank")
return value
class User(BaseConfig):
id: str
username: str
display_name: str
created_at: datetime
class CreateChat(BaseConfig):
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 validate_title(cls, value: str) -> str:
value = value.strip()
if not value:
raise ValueError("title must not be blank")
return value
@field_validator("member_ids")
@classmethod
def validate_unique_members(cls, value: List[str]) -> List[str]:
if len(value) != len(set(value)):
raise ValueError("member_ids must be unique")
return value
class Chat(BaseConfig):
id: str
title: str
member_ids: List[str]
created_at: datetime
class CreateMessage(BaseConfig):
text: str = Field(..., min_length=1, max_length=4000)
@field_validator("text")
@classmethod
def validate_text(cls, value: str) -> str:
value = value.strip()
if not value:
raise ValueError("text must not be blank")
return value
class Message(BaseConfig):
id: str
chat_id: str
sender_id: str
text: str
created_at: datetime
class Health(BaseConfig):
status: str = "ok"
class ErrorDetail(BaseConfig):
code: str
message: str
request_id: str
class ErrorResponse(BaseConfig):
error: ErrorDetail
class ChatPage(BaseConfig):
items: List[Chat]
next_cursor: Optional[str] = None
class MessagePage(BaseConfig):
items: List[Message]
next_cursor: Optional[str] = None
View File
+71
View File
@@ -0,0 +1,71 @@
import uuid
from sqlalchemy import select
from sqlalchemy.orm import Session, selectinload
from app.db.models import Chat, ChatMember
class ChatRepository:
def __init__(self, db: Session):
self.db = db
def get_by_id(self, chat_id: uuid.UUID) -> Chat | None:
statement = (
select(Chat)
.options(selectinload(Chat.members))
.where(Chat.id == chat_id)
)
return self.db.scalar(statement)
def get_by_user(
self,
user_id: uuid.UUID,
limit: int = 50,
) -> list[Chat]:
statement = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(ChatMember.user_id == user_id)
.order_by(Chat.created_at.asc(), Chat.id.asc())
.limit(limit)
)
return list(self.db.scalars(statement).all())
def is_member(
self,
chat_id: uuid.UUID,
user_id: uuid.UUID,
) -> bool:
statement = select(ChatMember).where(
ChatMember.chat_id == chat_id,
ChatMember.user_id == user_id,
)
return self.db.scalar(statement) is not None
def create(
self,
title: str,
member_ids: list[uuid.UUID],
) -> Chat:
chat = Chat(title=title)
self.db.add(chat)
self.db.flush()
memberships = [
ChatMember(
chat_id=chat.id,
user_id=user_id,
)
for user_id in member_ids
]
self.db.add_all(memberships)
self.db.flush()
return chat
+71
View File
@@ -0,0 +1,71 @@
import uuid
from datetime import datetime
from sqlalchemy import and_, or_, select
from sqlalchemy.orm import Session
from app.db.models import Message
class MessageRepository:
def __init__(self, db: Session):
self.db = db
def get_by_id(
self,
message_id: uuid.UUID,
) -> Message | None:
statement = select(Message).where(
Message.id == message_id
)
return self.db.scalar(statement)
def create(
self,
chat_id: uuid.UUID,
sender_id: uuid.UUID,
text: str,
) -> Message:
message = Message(
chat_id=chat_id,
sender_id=sender_id,
text=text,
)
self.db.add(message)
self.db.flush()
return message
def get_history(
self,
chat_id: uuid.UUID,
limit: int = 50,
cursor_created_at: datetime | None = None,
cursor_id: uuid.UUID | None = None,
) -> list[Message]:
statement = select(Message).where(
Message.chat_id == chat_id
)
if cursor_created_at is not None and cursor_id is not None:
statement = statement.where(
or_(
Message.created_at > cursor_created_at,
and_(
Message.created_at == cursor_created_at,
Message.id > cursor_id,
),
)
)
statement = (
statement
.order_by(Message.created_at.asc(), Message.id.asc())
.limit(limit)
)
return list(self.db.scalars(statement).all())
+78
View File
@@ -0,0 +1,78 @@
import uuid
from datetime import datetime, timezone
from sqlalchemy import delete, select
from sqlalchemy.orm import Session
from app.db.models import Session as UserSession
class SessionRepository:
def __init__(self, db: Session):
self.db = db
def create(
self,
user_id: uuid.UUID,
token_hash: str,
expires_at: datetime,
) -> UserSession:
session = UserSession(
user_id=user_id,
token_hash=token_hash,
expires_at=expires_at,
)
self.db.add(session)
self.db.flush()
return session
def get_by_token_hash(
self,
token_hash: str,
) -> UserSession | None:
statement = select(UserSession).where(
UserSession.token_hash == token_hash
)
return self.db.scalar(statement)
def get_valid_session(
self,
token_hash: str,
) -> UserSession | None:
now = datetime.now(timezone.utc)
statement = select(UserSession).where(
UserSession.token_hash == token_hash,
UserSession.expires_at > now,
)
return self.db.scalar(statement)
def delete_by_token_hash(
self,
token_hash: str,
) -> bool:
statement = (
delete(UserSession)
.where(UserSession.token_hash == token_hash)
.returning(UserSession.id)
)
return self.db.scalar(statement) is not None
def delete_expired(self) -> int:
now = datetime.now(timezone.utc)
statement = (
delete(UserSession)
.where(UserSession.expires_at <= now)
)
result = self.db.execute(statement)
return result.rowcount
+41
View File
@@ -0,0 +1,41 @@
import uuid
from sqlalchemy import select
from sqlalchemy.orm import Session
from app.db.models import User
class UserRepository:
def __init__(self, db: Session):
self.db = db
def get_by_id(self, user_id: uuid.UUID) -> User | None:
statement = select(User).where(User.id == user_id)
return self.db.scalar(statement)
def get_by_username(self, username: str) -> User | None:
statement = select(User).where(
User.username == username
)
return self.db.scalar(statement)
def create(
self,
username: str,
display_name: str,
password_hash: str,
) -> User:
user = User(
username=username,
display_name=display_name,
password_hash=password_hash,
)
self.db.add(user)
self.db.flush()
return user
View File
+159
View File
@@ -0,0 +1,159 @@
import hashlib
import secrets
from datetime import datetime, timedelta, timezone
from redis import Redis
from redis.backoff import NoBackoff
from redis.exceptions import RedisError
from redis.retry import Retry
from sqlalchemy.orm import Session
from app.core.config import settings
from app.db.models import User
from app.repositories.session_repository import SessionRepository
from app.repositories.user_repository import UserRepository
from app.services.user_service import password_hasher
class InvalidCredentialsError(Exception):
pass
class InvalidSessionError(Exception):
pass
class AuthService:
def __init__(self, db: Session):
self.db = db
self.sessions = SessionRepository(db)
self.users = UserRepository(db)
self._redis_available = True
self.redis = Redis.from_url(
settings.cache_url,
decode_responses=True,
socket_connect_timeout=0.5,
socket_timeout=0.5,
retry_on_timeout=False,
retry=Retry(NoBackoff(), 0),
)
@staticmethod
def _hash_token(token: str) -> str:
return hashlib.sha256(token.encode("utf-8")).hexdigest()
def create_session(self, username: str, password: str) -> dict:
user = self.users.get_by_username(username)
if user is None or not password_hasher.verify(
password, user.password_hash
):
raise InvalidCredentialsError("Invalid username or password")
token = secrets.token_urlsafe(32)
token_hash = self._hash_token(token)
expires_at = datetime.now(timezone.utc) + timedelta(
seconds=settings.session_ttl_seconds
)
try:
self.sessions.create(
user_id=user.id,
token_hash=token_hash,
expires_at=expires_at,
)
self.db.commit()
except Exception:
self.db.rollback()
raise
self._cache_session(token_hash, user.id, expires_at)
return {
"token": token,
"token_type": "Bearer",
"expires_at": expires_at,
"user": user,
}
def _cache_session(
self,
token_hash: str,
user_id,
expires_at,
) -> None:
if not self._redis_available:
return
ttl = max(
1,
int((expires_at - datetime.now(timezone.utc)).total_seconds()),
)
try:
self.redis.setex(
f"session:{token_hash}",
ttl,
str(user_id),
)
except RedisError:
self._redis_available = False
def authenticate(self, token: str) -> User:
token_hash = self._hash_token(token)
cached_user_id = None
if self._redis_available:
try:
cached_user_id = self.redis.get(
f"session:{token_hash}"
)
except RedisError:
self._redis_available = False
session = self.sessions.get_valid_session(token_hash)
if session is None:
if self._redis_available:
try:
self.redis.delete(f"session:{token_hash}")
except RedisError:
self._redis_available = False
raise InvalidSessionError(
"Session is invalid or expired"
)
if cached_user_id is None:
self._cache_session(
token_hash,
session.user_id,
session.expires_at,
)
return session.user
def delete_session(self, token: str) -> None:
token_hash = self._hash_token(token)
try:
deleted = self.sessions.delete_by_token_hash(token_hash)
if not deleted:
raise InvalidSessionError(
"Session is invalid or expired"
)
self.db.commit()
except Exception:
self.db.rollback()
raise
if self._redis_available:
try:
self.redis.delete(f"session:{token_hash}")
except RedisError:
self._redis_available = False
+94
View File
@@ -0,0 +1,94 @@
import uuid
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from app.db.models import Chat
from app.repositories.chat_repository import ChatRepository
from app.repositories.user_repository import UserRepository
class ChatNotFoundError(Exception):
pass
class ChatAccessError(Exception):
pass
class InvalidChatDataError(Exception):
pass
class ChatService:
def __init__(self, db: Session):
self.db = db
self.chats = ChatRepository(db)
self.users = UserRepository(db)
def create_chat(
self,
title: str,
member_ids: list[str],
creator_id: uuid.UUID,
) -> Chat:
title = title.strip()
if not title or len(title) > 100:
raise InvalidChatDataError("Invalid chat title")
if not member_ids or len(member_ids) > 100:
raise InvalidChatDataError("Invalid members")
try:
parsed_ids = [uuid.UUID(str(value)) for value in member_ids]
except (ValueError, TypeError, AttributeError):
raise InvalidChatDataError("Invalid member UUID") from None
if len(parsed_ids) != len(set(parsed_ids)):
raise InvalidChatDataError("Duplicate members")
if creator_id not in parsed_ids:
raise InvalidChatDataError("Creator must be a member")
for user_id in parsed_ids:
if self.users.get_by_id(user_id) is None:
raise InvalidChatDataError("Unknown member")
try:
chat = self.chats.create(
title=title,
member_ids=parsed_ids,
)
self.db.commit()
self.db.refresh(chat)
return chat
except IntegrityError as exc:
self.db.rollback()
raise InvalidChatDataError("Unable to create chat") from exc
except Exception:
self.db.rollback()
raise
def get_chat(self, chat_id: uuid.UUID, user_id: uuid.UUID) -> Chat:
chat = self.chats.get_by_id(chat_id)
if chat is None:
raise ChatNotFoundError()
if not self.chats.is_member(chat_id, user_id):
raise ChatNotFoundError()
return chat
def list_chats(self, user_id: uuid.UUID) -> list[Chat]:
return self.chats.get_by_user(user_id)
def check_membership(
self,
chat_id: uuid.UUID,
user_id: uuid.UUID,
) -> bool:
return self.chats.is_member(chat_id, user_id)
+360
View File
@@ -0,0 +1,360 @@
import base64
import hashlib
import json
import time
import uuid
from datetime import datetime
from types import SimpleNamespace
from redis import Redis
from redis.backoff import NoBackoff
from redis.exceptions import RedisError
from redis.retry import Retry
from sqlalchemy.orm import Session
from app.core.config import settings
from app.db.models import Message
from app.repositories.chat_repository import ChatRepository
from app.repositories.message_repository import MessageRepository
class MessageNotFoundError(Exception):
pass
class MessageAccessError(Exception):
pass
class InvalidMessageDataError(Exception):
pass
class MessageService:
def __init__(self, db: Session):
self.db = db
self.messages = MessageRepository(db)
self.chats = ChatRepository(db)
self._redis_available = True
self.redis = Redis.from_url(
settings.cache_url,
decode_responses=True,
socket_connect_timeout=0.5,
socket_timeout=0.5,
retry_on_timeout=False,
retry=Retry(NoBackoff(), 0),
)
@staticmethod
def encode_cursor(message: Message) -> str:
payload = {
"created_at": message.created_at.isoformat(),
"id": str(message.id),
}
raw = json.dumps(payload).encode("utf-8")
return (
base64.urlsafe_b64encode(raw)
.decode("ascii")
.rstrip("=")
)
@staticmethod
def decode_cursor(cursor: str | None):
if not cursor:
return None, None
try:
padded = cursor + "=" * (-len(cursor) % 4)
raw = base64.urlsafe_b64decode(padded.encode("ascii"))
payload = json.loads(raw.decode("utf-8"))
created_at = datetime.fromisoformat(payload["created_at"])
message_id = uuid.UUID(payload["id"])
if created_at.tzinfo is None:
raise ValueError("Cursor timestamp must include timezone")
return created_at, message_id
except (ValueError, TypeError, KeyError, UnicodeError):
raise InvalidMessageDataError("Invalid cursor") from None
def _version_key(self, chat_id: uuid.UUID) -> str:
return f"messages:version:{chat_id}"
def _cache_key(
self,
chat_id: uuid.UUID,
version: int,
limit: int,
cursor: str | None,
) -> str:
cursor_hash = hashlib.sha256(
(cursor or "first-page").encode("utf-8")
).hexdigest()[:16]
return (
f"messages:{chat_id}:v{version}:"
f"limit:{limit}:cursor:{cursor_hash}"
)
def _get_version(self, chat_id: uuid.UUID) -> int:
if not self._redis_available:
return 0
try:
value = self.redis.get(self._version_key(chat_id))
return int(value or 0)
except (RedisError, ValueError):
self._redis_available = False
return 0
def _bump_version(self, chat_id: uuid.UUID) -> None:
if not self._redis_available:
return
try:
self.redis.incr(self._version_key(chat_id))
except RedisError:
self._redis_available = False
@staticmethod
def _serialize(messages, next_cursor):
return json.dumps({
"items": [
{
"id": str(message.id),
"chat_id": str(message.chat_id),
"sender_id": str(message.sender_id),
"text": message.text,
"created_at": message.created_at.isoformat(),
}
for message in messages
],
"next_cursor": next_cursor,
})
@staticmethod
def _deserialize(payload: str):
data = json.loads(payload)
messages = [
SimpleNamespace(
id=uuid.UUID(item["id"]),
chat_id=uuid.UUID(item["chat_id"]),
sender_id=uuid.UUID(item["sender_id"]),
text=item["text"],
created_at=datetime.fromisoformat(item["created_at"]),
)
for item in data["items"]
]
return messages, data["next_cursor"]
def _read_cache(self, key: str):
if not self._redis_available:
return None
try:
payload = self.redis.get(key)
if payload is None:
return None
return self._deserialize(payload)
except RedisError:
self._redis_available = False
return None
except (ValueError, TypeError, KeyError):
return None
def _load_from_database(
self,
chat_id,
limit,
cursor_created_at,
cursor_id,
):
rows = self.messages.get_history(
chat_id=chat_id,
limit=limit + 1,
cursor_created_at=cursor_created_at,
cursor_id=cursor_id,
)
has_more = len(rows) > limit
items = rows[:limit]
next_cursor = (
self.encode_cursor(items[-1])
if has_more and items
else None
)
return items, next_cursor
def create_message(
self,
chat_id: uuid.UUID,
sender_id: uuid.UUID,
text: str,
) -> Message:
text = text.strip()
if not text or len(text) > 4000:
raise InvalidMessageDataError("Invalid message text")
if not self.chats.is_member(chat_id, sender_id):
raise MessageNotFoundError()
try:
message = self.messages.create(
chat_id=chat_id,
sender_id=sender_id,
text=text,
)
self.db.commit()
self.db.refresh(message)
self._bump_version(chat_id)
return message
except Exception:
self.db.rollback()
raise
def get_history(
self,
chat_id: uuid.UUID,
user_id: uuid.UUID,
limit: int = 50,
cursor: str | None = None,
):
if not 1 <= limit <= 100:
raise InvalidMessageDataError(
"Limit must be between 1 and 100"
)
if not self.chats.is_member(chat_id, user_id):
raise MessageNotFoundError()
cursor_created_at, cursor_id = self.decode_cursor(cursor)
version = self._get_version(chat_id)
cache_key = self._cache_key(
chat_id,
version,
limit,
cursor,
)
cached = self._read_cache(cache_key)
if cached is not None:
return cached
if not self._redis_available:
return self._load_from_database(
chat_id,
limit,
cursor_created_at,
cursor_id,
)
lock_key = f"lock:{cache_key}"
lock_token = str(uuid.uuid4())
try:
acquired = self.redis.set(
lock_key,
lock_token,
nx=True,
ex=10,
)
except RedisError:
self._redis_available = False
return self._load_from_database(
chat_id,
limit,
cursor_created_at,
cursor_id,
)
if not acquired:
for _ in range(10):
time.sleep(0.05)
cached = self._read_cache(cache_key)
if cached is not None:
return cached
if not self._redis_available:
break
return self._load_from_database(
chat_id,
limit,
cursor_created_at,
cursor_id,
)
try:
cached = self._read_cache(cache_key)
if cached is not None:
return cached
if not self._redis_available:
return self._load_from_database(
chat_id,
limit,
cursor_created_at,
cursor_id,
)
items, next_cursor = self._load_from_database(
chat_id,
limit,
cursor_created_at,
cursor_id,
)
if self._redis_available and self._get_version(chat_id) == version:
try:
self.redis.setex(
cache_key,
settings.message_cache_ttl_seconds,
self._serialize(items, next_cursor),
)
except RedisError:
self._redis_available = False
return items, next_cursor
finally:
if self._redis_available:
try:
self.redis.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 RedisError:
self._redis_available = False
+81
View File
@@ -0,0 +1,81 @@
import re
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from pwdlib import PasswordHash
from app.db.models import User
from app.repositories.user_repository import UserRepository
password_hasher = PasswordHash.recommended()
class UsernameAlreadyExistsError(Exception):
pass
class UserService:
def __init__(self, db: Session):
self.db = db
self.users = UserRepository(db)
def register(
self,
username: str,
display_name: str,
password: str,
) -> User:
if not re.fullmatch(r"[a-z0-9_]{3,32}", username):
raise ValueError("Invalid username")
if not display_name or not display_name.strip():
raise ValueError("Display name cannot be empty")
if len(display_name) > 100:
raise ValueError("Display name is too long")
if not 12 <= len(password) <= 128:
raise ValueError("Invalid password length")
if self.users.get_by_username(username) is not None:
raise UsernameAlreadyExistsError(
"Username already exists"
)
password_hash = password_hasher.hash(password)
try:
user = self.users.create(
username=username,
display_name=display_name,
password_hash=password_hash,
)
self.db.commit()
self.db.refresh(user)
return user
except IntegrityError as exc:
self.db.rollback()
raise UsernameAlreadyExistsError(
"Username already exists"
) from exc
except Exception:
self.db.rollback()
raise
def verify_password(
self,
user: User,
password: str,
) -> bool:
return password_hasher.verify(
password,
user.password_hash,
)
+193
View File
@@ -0,0 +1,193 @@
import base64
import bisect
import binascii
import json
import os
import threading
import uuid
from datetime import datetime, timezone
from typing import Dict, List, Optional, Tuple
from .models import Chat, Message, User
Key = Tuple[datetime, str]
def _encode_cursor(kind: str, scope: str, item) -> str:
payload = {
"v": 1,
"kind": kind,
"scope": scope,
"created_at": item.created_at.isoformat(),
"id": item.id,
}
raw = json.dumps(payload, separators=(",", ":")).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
def _decode_cursor(cursor: str, kind: str, scope: str) -> Key:
try:
if not cursor or len(cursor) > 4096:
raise ValueError
padded = cursor + "=" * (-len(cursor) % 4)
raw = base64.b64decode(padded, altchars=b"-_", validate=True)
payload = json.loads(raw.decode("utf-8"))
if not isinstance(payload, dict) or payload.get("v") != 1:
raise ValueError
if payload.get("kind") != kind or payload.get("scope") != scope:
raise ValueError
item_id = payload.get("id")
timestamp = payload.get("created_at")
if not isinstance(item_id, str) or not isinstance(timestamp, str):
raise ValueError
created_at = datetime.fromisoformat(timestamp)
if created_at.tzinfo is None:
raise ValueError
created_at = created_at.astimezone(timezone.utc)
return created_at, item_id
except (
ValueError,
TypeError,
KeyError,
UnicodeDecodeError,
json.JSONDecodeError,
binascii.Error,
):
raise ValueError("invalid_request") from None
class InMemoryStore:
def __init__(self):
self._lock = threading.RLock()
self.users: Dict[str, User] = {}
self.chats: Dict[str, Chat] = {}
self.messages: Dict[str, List[Message]] = {}
self.usernames: Dict[str, str] = {}
self.message_keys: Dict[str, List[Key]] = {}
self.message_index_enabled = os.getenv("MESSAGE_INDEX_ENABLED", "1") != "0"
def create_user(self, username: str, display_name: str) -> User:
with self._lock:
if username in self.usernames:
raise ValueError("conflict")
user_id = str(uuid.uuid4())
user = User(
id=user_id,
username=username,
display_name=display_name,
created_at=datetime.now(timezone.utc),
)
self.users[user_id] = user
self.usernames[username] = user_id
return user
def get_user(self, user_id: str) -> Optional[User]:
with self._lock:
return self.users.get(user_id)
def create_chat(self, title: str, member_ids: List[str], creator_id: str) -> Chat:
with self._lock:
if creator_id not in member_ids or len(member_ids) != len(set(member_ids)):
raise ValueError("invalid_request")
if any(member_id not in self.users for member_id in member_ids):
raise ValueError("invalid_request")
chat_id = str(uuid.uuid4())
chat = Chat(
id=chat_id,
title=title,
member_ids=list(member_ids),
created_at=datetime.now(timezone.utc),
)
self.chats[chat_id] = chat
self.messages[chat_id] = []
self.message_keys[chat_id] = []
return chat
def get_chat(self, chat_id: str, user_id: str) -> Optional[Chat]:
with self._lock:
chat = self.chats.get(chat_id)
if chat is None or user_id not in chat.member_ids:
return None
return chat
def list_chats(
self, user_id: str, limit: int, cursor: Optional[str]
) -> Tuple[List[Chat], Optional[str]]:
with self._lock:
user_chats = [chat for chat in self.chats.values() if user_id in chat.member_ids]
user_chats.sort(key=lambda chat: (chat.created_at, chat.id))
keys = [(chat.created_at, chat.id) for chat in user_chats]
start_index = 0
if cursor:
target_key = _decode_cursor(cursor, kind="chats", scope=user_id)
start_index = bisect.bisect_right(keys, target_key)
page_with_extra = user_chats[start_index : start_index + limit + 1]
has_next = len(page_with_extra) > limit
page = page_with_extra[:limit]
next_cursor = None
if has_next and page:
next_cursor = _encode_cursor("chats", user_id, page[-1])
return page, next_cursor
def create_message(self, chat_id: str, sender_id: str, text: str) -> Message:
with self._lock:
chat = self.chats.get(chat_id)
if chat is None or sender_id not in chat.member_ids:
raise ValueError("not_found")
message = Message(
id=str(uuid.uuid4()),
chat_id=chat_id,
sender_id=sender_id,
text=text,
created_at=datetime.now(timezone.utc),
)
messages = self.messages[chat_id]
keys = self.message_keys[chat_id]
key = (message.created_at, message.id)
if self.message_index_enabled:
index = bisect.bisect_right(keys, key)
keys.insert(index, key)
messages.insert(index, message)
else:
current_keys = [(item.created_at, item.id) for item in messages]
index = bisect.bisect_right(current_keys, key)
messages.insert(index, message)
keys.insert(index, key)
return message
def list_messages(
self,
chat_id: str,
user_id: str,
limit: int,
cursor: Optional[str],
) -> Tuple[List[Message], Optional[str]]:
with self._lock:
chat = self.chats.get(chat_id)
if chat is None or user_id not in chat.member_ids:
raise ValueError("not_found")
messages = self.messages[chat_id]
if self.message_index_enabled:
keys = self.message_keys[chat_id]
else:
keys = [(item.created_at, item.id) for item in messages]
start_index = 0
if cursor:
target_key = _decode_cursor(cursor, kind="messages", scope=chat_id)
start_index = bisect.bisect_right(keys, target_key)
page_with_extra = messages[start_index : start_index + limit + 1]
has_next = len(page_with_extra) > limit
page = page_with_extra[:limit]
next_cursor = None
if has_next and page:
next_cursor = _encode_cursor("messages", chat_id, page[-1])
return page, next_cursor
+69
View File
@@ -0,0 +1,69 @@
services:
postgres:
image: postgres:16.6
container_name: mtusi-lab2-postgres
restart: unless-stopped
environment:
POSTGRES_DB: ${POSTGRES_DB}
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
ports:
- "${POSTGRES_HOST_PORT}:5432"
volumes:
- lab2_postgres_data:/var/lib/postgresql/data
healthcheck:
test:
- CMD-SHELL
- pg_isready -U "$$POSTGRES_USER" -d "$$POSTGRES_DB"
interval: 5s
timeout: 5s
retries: 10
start_period: 10s
redis:
image: redis:7.4.2
container_name: mtusi-lab2-redis
restart: unless-stopped
command: redis-server --appendonly yes
ports:
- "${REDIS_PORT}:6379"
volumes:
- lab2_redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
api:
build:
context: .
dockerfile: Dockerfile
container_name: mtusi-lab2-api
restart: unless-stopped
environment:
DATABASE_URL: postgresql+psycopg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
CACHE_URL: redis://redis:6379/0
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
MESSAGE_CACHE_TTL_SECONDS: ${MESSAGE_CACHE_TTL_SECONDS:-60}
ports:
- "8080:8080"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
healthcheck:
test:
- CMD
- python
- -c
- "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=3)"
interval: 10s
timeout: 5s
retries: 5
start_period: 30s
volumes:
lab2_postgres_data:
lab2_redis_data:
+11
View File
@@ -0,0 +1,11 @@
{
"experiment": "Redis message history cache",
"cold_read_ms": 52.287,
"warm_reads": 30,
"warm_mean_ms": 26.478,
"warm_median_ms": 29.496,
"warm_min_ms": 13.785,
"warm_max_ms": 46.404,
"read_after_write": "PASS",
"limitations": "HTTP latency includes client, network, authentication and API overhead; it is not a direct SQL query count."
}
+12
View File
@@ -0,0 +1,12 @@
{
"experiment": "concurrent cache miss / stampede",
"workers": 12,
"cold_concurrent_requests": 12,
"warm_concurrent_requests": 12,
"cold_batch_elapsed_ms": 172.0,
"warm_batch_elapsed_ms": 110.0,
"cold_message_select_statements": 0,
"warm_message_select_statements": 0,
"result": "PASS",
"note": "PostgreSQL log_min_duration_statement was temporarily set to 0 and restored after the experiment. Counts are filtered to SELECT statements whose SQL contains FROM messages."
}
Binary file not shown.
Binary file not shown.
Binary file not shown.
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 10.0,
"elapsed_seconds": 10.531,
"concurrency": 4,
"successful_requests": 674,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 64.002,
"successful_latency_ms": {
"p50": 62.0,
"p95": 94.0,
"p99": 110.0
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
Binary file not shown.
Binary file not shown.
Binary file not shown.
+1
View File
@@ -0,0 +1 @@
Generic single-database configuration.
+60
View File
@@ -0,0 +1,60 @@
from logging.config import fileConfig
from alembic import context
from sqlalchemy import engine_from_config, pool
from app.core.config import settings
from app.db.base import Base
from app.db import models
config = context.config
if config.config_file_name is not None:
fileConfig(config.config_file_name)
config.set_main_option(
"sqlalchemy.url",
settings.database_url.replace("%", "%%"),
)
target_metadata = Base.metadata
def run_migrations_offline() -> None:
url = settings.database_url
context.configure(
url=url,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
compare_type=True,
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online() -> None:
connectable = engine_from_config(
config.get_section(config.config_ini_section, {}),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata,
compare_type=True,
)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+26
View File
@@ -0,0 +1,26 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
# revision identifiers, used by Alembic.
revision: str = ${repr(up_revision)}
down_revision: Union[str, None] = ${repr(down_revision)}
branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
def upgrade() -> None:
${upgrades if upgrades else "pass"}
def downgrade() -> None:
${downgrades if downgrades else "pass"}
@@ -0,0 +1,79 @@
"""create initial database schema
Revision ID: 21ad89656327
Revises:
Create Date: 2026-11-04 17:31:39.336368
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision: str = '21ad89656327'
down_revision: Union[str, None] = None
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('chats',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('title', sa.String(length=100), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.PrimaryKeyConstraint('id')
)
op.create_table('users',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('username', sa.String(length=32), nullable=False),
sa.Column('display_name', sa.String(length=100), nullable=False),
sa.Column('password_hash', sa.String(length=255), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True)
op.create_table('chat_members',
sa.Column('chat_id', sa.UUID(), nullable=False),
sa.Column('user_id', sa.UUID(), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('chat_id', 'user_id')
)
op.create_table('messages',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('chat_id', sa.UUID(), nullable=False),
sa.Column('sender_id', sa.UUID(), nullable=False),
sa.Column('text', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_index('ix_messages_chat_created_id', 'messages', ['chat_id', 'created_at', 'id'], unique=False)
op.create_table('sessions',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('token_hash', sa.String(length=64), nullable=False),
sa.Column('user_id', sa.UUID(), nullable=False),
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_sessions_token_hash'), 'sessions', ['token_hash'], unique=True)
# ### end Alembic commands ###
def downgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index(op.f('ix_sessions_token_hash'), table_name='sessions')
op.drop_table('sessions')
op.drop_index('ix_messages_chat_created_id', table_name='messages')
op.drop_table('messages')
op.drop_table('chat_members')
op.drop_index(op.f('ix_users_username'), table_name='users')
op.drop_table('users')
op.drop_table('chats')
# ### end Alembic commands ###
+9
View File
@@ -0,0 +1,9 @@
fastapi==0.115.6
uvicorn[standard]==0.34.0
pydantic==2.10.4
pydantic-settings==2.7.1
SQLAlchemy==2.0.36
psycopg[binary]==3.2.3
alembic==1.14.0
redis==5.2.1
pwdlib[argon2]==0.2.1
+13
View File
@@ -0,0 +1,13 @@
-- Run with:
-- docker compose exec -T postgres psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" < scripts/explain_history.sql
-- This script selects an existing chat and explains the exact keyset history query.
-- For the required >=10,000-row experiment, seed the chosen chat first, then ANALYZE.
\pset pager off
SELECT count(*) AS total_messages FROM messages;
ANALYZE messages;
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = (SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1)
ORDER BY created_at ASC, id ASC
LIMIT 51;
+30
View File
@@ -0,0 +1,30 @@
$ErrorActionPreference = "Stop"
$ProjectRoot = Split-Path -Parent $PSScriptRoot
Push-Location $ProjectRoot
try {
Write-Host "Restarting API, PostgreSQL and Redis without removing volumes..."
docker compose restart api postgres redis
if ($LASTEXITCODE -ne 0) { throw "docker compose restart failed" }
$deadline = (Get-Date).AddSeconds(90)
do {
Start-Sleep -Seconds 2
$ready = $false
try {
$response = Invoke-RestMethod -Uri "http://127.0.0.1:8080/health/ready" -TimeoutSec 3
$ready = ($response.status -eq "ok")
} catch { }
if ($ready) {
$states = docker compose ps --format json | ConvertFrom-Json
$healthy = @($states | Where-Object { $_.Health -eq "healthy" })
if ($healthy.Count -ge 3) {
Write-Host "PASS: API and both stores are healthy. Named volumes were preserved."
exit 0
}
}
} while ((Get-Date) -lt $deadline)
throw "Stack did not become healthy within 90 seconds"
}
finally {
Pop-Location
}
+64
View File
@@ -0,0 +1,64 @@
import json
import statistics
import time
from pathlib import Path
from client import Client, check, run
def main():
client = Client()
alice, _, _, chat = client.bootstrap()
path = f"/api/v1/chats/{chat['id']}/messages?limit=50"
# Первое чтение — холодный кэш.
started = time.perf_counter()
client.call("GET", path, actor=alice, schema="MessagePage")
cold_ms = (time.perf_counter() - started) * 1000
# Повторные чтения — прогретый кэш.
warm = []
for _ in range(30):
started = time.perf_counter()
client.call("GET", path, actor=alice, schema="MessagePage")
warm.append((time.perf_counter() - started) * 1000)
# Проверка актуальности после записи.
marker = "cache-read-after-write-check"
client.message(alice, chat, marker)
updated = client.call(
"GET", path, actor=alice, schema="MessagePage"
)
texts = [item["text"] for item in updated["json"]["items"]]
check(marker in texts, "Read-after-write failed: new message is missing")
result = {
"experiment": "Redis message history cache",
"cold_read_ms": round(cold_ms, 3),
"warm_reads": len(warm),
"warm_mean_ms": round(statistics.mean(warm), 3),
"warm_median_ms": round(statistics.median(warm), 3),
"warm_min_ms": round(min(warm), 3),
"warm_max_ms": round(max(warm), 3),
"read_after_write": "PASS",
"limitations": (
"HTTP latency includes client, network, authentication "
"and API overhead; it is not a direct SQL query count."
),
}
output = Path("evidence/cache-research.json")
output.parent.mkdir(parents=True, exist_ok=True)
output.write_text(
json.dumps(result, indent=2, ensure_ascii=False) + "\n",
encoding="utf-8",
)
print(json.dumps(result, indent=2, ensure_ascii=False))
if __name__ == "__main__":
run(main)
+374
View File
@@ -0,0 +1,374 @@
#!/usr/bin/env python3
"""Grade-5 verification scenarios for Lab 2. Uses only synthetic records."""
from __future__ import annotations
import base64
from datetime import datetime, timezone
import json
import os
import re
import subprocess
import threading
import time
import uuid
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from client import Client, Failure, check, run
ROOT = Path(__file__).resolve().parents[1]
def env_file():
result = {}
path = ROOT / ".env"
if path.exists():
for line in path.read_text(encoding="utf-8-sig").splitlines():
line = line.strip()
if not line or line.startswith("#") or "=" not in line:
continue
key, value = line.split("=", 1)
result[key.strip()] = value.strip().strip('"').strip("'")
return result
ENV = env_file()
def docker(*args, input_text=None, check_ok=True, timeout=60):
proc = subprocess.run(
["docker", "compose", *args],
cwd=ROOT,
input=input_text,
text=True,
capture_output=True,
timeout=timeout,
)
if check_ok and proc.returncode:
raise Failure(
"docker compose " + " ".join(args)
+ " failed: " + (proc.stderr or proc.stdout)[-1500:]
)
return proc
def psql(sql: str) -> str:
user = ENV.get("POSTGRES_USER", "messenger")
database = ENV.get("POSTGRES_DB", "messenger")
proc = subprocess.run(
[
"docker", "compose", "exec", "-T", "postgres",
"psql", "-X", "-A", "-t", "-v", "ON_ERROR_STOP=1",
"-U", user, "-d", database,
],
cwd=ROOT,
input=sql,
text=True,
capture_output=True,
timeout=30,
)
if proc.returncode:
raise Failure("PostgreSQL test query failed: " + proc.stderr[-1200:])
return proc.stdout.strip()
def wait_api(base_url: str, timeout: int = 90):
deadline = time.monotonic() + timeout
last = None
while time.monotonic() < deadline:
try:
Client(base_url, timeout=2).call(
"GET", "/health/ready", schema="Health"
)
return
except Exception as exc:
last = exc
time.sleep(1)
raise Failure(f"API did not become ready: {last}")
def wait_redis(timeout: int = 60):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
proc = docker("exec", "-T", "redis", "redis-cli", "ping", check_ok=False)
if proc.returncode == 0 and "PONG" in proc.stdout:
return
time.sleep(1)
raise Failure("Redis did not recover")
def registration_race(base_url: str):
client = Client(base_url, timeout=15)
username = "race_" + uuid.uuid4().hex[:16]
password = "Race-" + uuid.uuid4().hex
body = {
"username": username,
"display_name": "Concurrent registration",
"password": password,
}
workers = 12
barrier = threading.Barrier(workers)
def attempt(_):
barrier.wait(timeout=10)
return client.call(
"POST", "/api/v1/users", expected=[201, 409],
body=body, schema="User",
)["status"]
with ThreadPoolExecutor(max_workers=workers) as pool:
statuses = list(pool.map(attempt, range(workers)))
check(statuses.count(201) == 1, f"registration race: expected 1 success, got {statuses.count(201)}")
check(statuses.count(409) == workers - 1, f"registration race: expected {workers-1} conflicts, got {statuses}")
count = psql(
"SELECT count(*) FROM users WHERE username = "
+ "'" + username + "';"
)
check(count == "1", f"registration race left {count} database rows")
print(f"PASS registration race: {workers} concurrent requests, 1 created, {workers-1} conflicts, 1 DB row")
def chat_rollback(base_url: str):
client = Client(base_url)
alice, bob, _, _ = client.bootstrap()
before = int(psql("SELECT count(*) FROM chats;"))
psql("""
CREATE OR REPLACE FUNCTION lab2_test_reject_membership()
RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
RAISE EXCEPTION 'lab2 injected membership failure';
END;
$$;
DROP TRIGGER IF EXISTS lab2_test_reject_membership_trigger ON chat_members;
CREATE TRIGGER lab2_test_reject_membership_trigger
BEFORE INSERT ON chat_members
FOR EACH ROW EXECUTE FUNCTION lab2_test_reject_membership();
""")
try:
response = client.call(
"POST", "/api/v1/chats", expected=500,
actor=alice,
body={
"title": "Rollback verification",
"member_ids": [alice["id"], bob["id"]],
},
)
check(response["status"] == 500, "injected membership failure did not fail request")
finally:
psql("""
DROP TRIGGER IF EXISTS lab2_test_reject_membership_trigger ON chat_members;
DROP FUNCTION IF EXISTS lab2_test_reject_membership();
""")
after = int(psql("SELECT count(*) FROM chats;"))
check(after == before, f"chat rollback failed: chat count changed {before} -> {after}")
print("PASS chat rollback: injected membership failure left no partial chat")
def short_ttl(base_url: str):
override = ROOT / "compose.ttl-test.yaml"
override.write_text(
'services:\n api:\n environment:\n SESSION_TTL_SECONDS: "3"\n',
encoding="utf-8",
)
try:
docker("-f", "compose.yaml", "-f", "compose.ttl-test.yaml",
"up", "-d", "--force-recreate", "api", timeout=180)
wait_api(base_url)
client = Client(base_url, timeout=10)
actor = client.user("shortttl")
time.sleep(4)
expired = client.call(
"GET", "/api/v1/users/me", expected=401, actor=actor
)
check(expired["status"] == 401, "expired Bearer session was accepted")
print("PASS short TTL: 3-second session was rejected after expiry")
finally:
try:
override.unlink(missing_ok=True)
finally:
docker("up", "-d", "--force-recreate", "api", timeout=180)
wait_api(base_url)
def redis_outage(base_url: str):
client = Client(base_url, timeout=10)
alice, _, _, chat = client.bootstrap()
client.message(alice, chat, "redis-outage-history-check")
docker("stop", "redis")
try:
response = client.call(
"GET",
f"/api/v1/chats/{chat['id']}/messages?limit=50",
actor=alice,
schema="MessagePage",
)
texts = [item["text"] for item in response["json"]["items"]]
check("redis-outage-history-check" in texts, "history unavailable while Redis is down")
client.call("GET", "/api/v1/users/me", actor=alice, schema="User")
print("PASS Redis outage: history and Bearer authentication remained available via PostgreSQL")
finally:
docker("start", "redis")
wait_redis()
wait_api(base_url)
def postgres_outage(base_url: str):
client = Client(base_url, timeout=5)
actor = client.user("dboutage")
docker("stop", "postgres")
try:
health = client.call("GET", "/health/ready", expected=503)
check(health["status"] == 503, "readiness did not report PostgreSQL outage")
protected = client.call(
"GET", "/api/v1/users/me", expected=[500, 503], actor=actor
)
check(
protected["status"] in (500, 503),
"protected request unexpectedly succeeded without PostgreSQL",
)
print("PASS PostgreSQL outage: readiness returned 503 and protected request failed closed")
finally:
docker("start", "postgres")
deadline = time.monotonic() + 90
user = ENV.get("POSTGRES_USER", "messenger")
database = ENV.get("POSTGRES_DB", "messenger")
while time.monotonic() < deadline:
proc = docker(
"exec", "-T", "postgres", "pg_isready",
"-U", user, "-d", database, check_ok=False
)
if proc.returncode == 0:
break
time.sleep(1)
else:
raise Failure("PostgreSQL did not recover within 90 seconds")
wait_api(base_url)
def redis_key_cleanup(chat_id: str):
patterns = [f"messages:{chat_id}:*", f"lock:messages:{chat_id}:*"]
for pattern in patterns:
scan = docker("exec", "-T", "redis", "redis-cli", "--scan", "--pattern", pattern)
keys = [line.strip() for line in scan.stdout.splitlines() if line.strip()]
if keys:
docker("exec", "-T", "redis", "redis-cli", "DEL", *keys)
def cache_stampede(base_url: str):
previous = psql("SHOW log_min_duration_statement;")
psql("ALTER SYSTEM SET log_min_duration_statement = 0; SELECT pg_reload_conf();")
def logged_message_selects(since: str):
logs = subprocess.run(
["docker", "logs", "--since", since, "mtusi-lab2-postgres"],
cwd=ROOT,
text=True,
capture_output=True,
timeout=30,
)
lines = (logs.stdout + "\n" + logs.stderr).splitlines()
return [
line for line in lines
if re.search(r"statement:\s*SELECT", line, re.I)
and re.search(r"\bFROM\s+messages\b", line, re.I)
]
try:
client = Client(base_url, timeout=15)
alice, _, _, chat = client.bootstrap()
for i in range(5):
client.message(alice, chat, f"stampede-seed-{i}")
path = f"/api/v1/chats/{chat['id']}/messages?limit=50"
redis_key_cleanup(chat["id"])
workers = 12
barrier = threading.Barrier(workers)
def get_history(_):
barrier.wait(timeout=10)
return client.call("GET", path, actor=alice, schema="MessagePage")
cold_since = datetime.now(timezone.utc).isoformat(timespec="milliseconds")
started = time.monotonic()
with ThreadPoolExecutor(max_workers=workers) as pool:
cold_results = list(pool.map(get_history, range(workers)))
cold_elapsed = (time.monotonic() - started) * 1000
check(all(r["status"] == 200 for r in cold_results), "cold concurrent history request failed")
cold_selects = logged_message_selects(cold_since)
warm_since = datetime.now(timezone.utc).isoformat(timespec="milliseconds")
started = time.monotonic()
with ThreadPoolExecutor(max_workers=workers) as pool:
warm_results = list(pool.map(get_history, range(workers)))
warm_elapsed = (time.monotonic() - started) * 1000
check(all(r["status"] == 200 for r in warm_results), "warm concurrent history request failed")
warm_selects = logged_message_selects(warm_since)
check(
len(cold_selects) <= 2,
f"cache stampede protection ineffective: {len(cold_selects)} message SELECTs for {workers} simultaneous misses",
)
check(
len(warm_selects) == 0,
f"warm cache unexpectedly issued {len(warm_selects)} message SELECTs",
)
result = {
"experiment": "concurrent cache miss / stampede",
"workers": workers,
"cold_concurrent_requests": len(cold_results),
"warm_concurrent_requests": len(warm_results),
"cold_batch_elapsed_ms": round(cold_elapsed, 3),
"warm_batch_elapsed_ms": round(warm_elapsed, 3),
"cold_message_select_statements": len(cold_selects),
"warm_message_select_statements": len(warm_selects),
"result": "PASS",
"note": "PostgreSQL log_min_duration_statement was temporarily set to 0 and restored after the experiment. Counts are filtered to SELECT statements whose SQL contains FROM messages.",
}
out = ROOT / "evidence" / "cache-stampede.json"
out.parent.mkdir(exist_ok=True)
out.write_text(json.dumps(result, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
(ROOT / "evidence" / "cache-stampede-cold.log").write_text(
"\n".join(cold_selects) + "\n", encoding="utf-8"
)
(ROOT / "evidence" / "cache-stampede-warm.log").write_text(
"\n".join(warm_selects) + "\n", encoding="utf-8"
)
print(json.dumps(result, indent=2, ensure_ascii=False))
print("PASS cache stampede: concurrent cold misses collapsed; warm cache issued no message SELECT")
finally:
psql("ALTER SYSTEM SET log_min_duration_statement = " + previous + "; SELECT pg_reload_conf();")
def main():
def configure(parser):
parser.add_argument("--base-url", default="http://127.0.0.1:8080")
parser.add_argument(
"--only",
choices=["all", "registration", "rollback", "ttl", "redis", "postgres", "stampede"],
default="all",
)
import argparse
parser = argparse.ArgumentParser(description="Run Lab 2 grade-5 verification scenarios")
configure(parser)
args = parser.parse_args()
if args.only in ("all", "registration"):
registration_race(args.base_url)
if args.only in ("all", "rollback"):
chat_rollback(args.base_url)
if args.only in ("all", "ttl"):
short_ttl(args.base_url)
if args.only in ("all", "redis"):
redis_outage(args.base_url)
if args.only in ("all", "postgres"):
postgres_outage(args.base_url)
if args.only in ("all", "stampede"):
cache_stampede(args.base_url)
if __name__ == "__main__":
run(main)
+47
View File
@@ -0,0 +1,47 @@
"""Windows-compatible persistence acceptance test for Docker Compose."""
import subprocess
import sys
import time
from pathlib import Path
from client import Client, arguments, check, run
ROOT = Path(__file__).resolve().parents[1]
def main():
args = arguments("Windows-compatible PostgreSQL/session persistence scenario")
c = Client(args.base_url, args.ca_file, timeout=5)
alice, bob, eve, chat = c.bootstrap()
original = c.message(alice, chat, "Проверка сохранности после рестарта")["json"]
token = alice["token"]
hook = ROOT / "scripts" / "restart.ps1"
check(hook.is_file(), "scripts/restart.ps1 is missing")
result = subprocess.run(
["powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", str(hook)],
cwd=str(ROOT), timeout=110, capture_output=True, text=True
)
if result.returncode:
print(result.stdout)
print(result.stderr, file=sys.stderr)
check(False, "PowerShell restart hook failed")
deadline = time.monotonic() + 90
while True:
try:
c.call("GET", "/health/ready", schema="Health")
break
except Exception:
check(time.monotonic() < deadline, "API did not recover")
time.sleep(1)
same_actor = {"id": alice["id"], "token": token}
me = c.call("GET", "/api/v1/users/me", actor=same_actor, schema="User")["json"]
check(me["id"] == alice["id"], "existing session did not survive restart")
history = c.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100",
actor={"id": bob["id"], "token": bob["token"]},
schema="MessagePage")["json"]
check(original in history["items"], "confirmed message did not survive restart")
print("PASS: PostgreSQL data and existing Bearer session survived API + PostgreSQL + Redis restart.")
if __name__ == "__main__":
run(main)