From 1e1fd22ccf787856d0cf506366510facba12934b Mon Sep 17 00:00:00 2001 From: sinveria Date: Thu, 5 Nov 2026 18:29:36 +0300 Subject: [PATCH] Complete lab 3 load balancing and resilience --- Dockerfile | 19 + REPORT.md | 361 ++++++++++++++- alembic.ini | 117 +++++ app/__init__.py | 0 app/api/__init__.py | 0 app/api/auth.py | 96 ++++ app/api/chats.py | 90 ++++ app/api/deps.py | 40 ++ app/api/messages.py | 73 +++ app/api/users.py | 55 +++ app/core/__init__.py | 0 app/core/config.py | 24 + app/db/__init__.py | 0 app/db/base.py | 5 + app/db/models.py | 215 +++++++++ app/db/session.py | 15 + app/main.py | 86 ++++ app/models.py | 110 +++++ app/repositories/__init__.py | 0 app/repositories/chat_repository.py | 71 +++ app/repositories/message_repository.py | 71 +++ app/repositories/session_repository.py | 78 ++++ app/repositories/user_repository.py | 41 ++ app/services/__init__.py | 0 app/services/auth_service.py | 159 +++++++ app/services/chat_service.py | 94 ++++ app/services/message_service.py | 418 ++++++++++++++++++ app/services/user_service.py | 81 ++++ app/store.py | 193 ++++++++ compose.yaml | 143 ++++++ evidence/concurrent-1.txt | 2 + evidence/concurrent-10.txt | 2 + evidence/concurrent-2.txt | 2 + evidence/concurrent-3.txt | 2 + evidence/concurrent-4.txt | 2 + evidence/concurrent-5.txt | 2 + evidence/concurrent-6.txt | 2 + evidence/concurrent-7.txt | 2 + evidence/concurrent-8.txt | 2 + evidence/concurrent-9.txt | 2 + evidence/concurrent-summary.txt | 5 + evidence/failover/replica-1.txt | 3 + evidence/failover/replica-2.txt | 3 + evidence/rolling-update-diagnostic.json | 42 ++ evidence/rolling-update-final.json | 41 ++ evidence/rolling-update-load.json | 17 + evidence/scaling/errors.png | Bin 0 -> 51152 bytes .../expanded_4replicas_2cpu_2048mb.json | 194 ++++++++ .../expanded_4replicas_3cpu_3072mb.json | 177 ++++++++ .../expanded_4replicas_4cpu_4096mb.json | 195 ++++++++ evidence/scaling/fixed_1replicas.json | 163 +++++++ evidence/scaling/fixed_2replicas.json | 175 ++++++++ evidence/scaling/fixed_4replicas.json | 195 ++++++++ evidence/scaling/p95-latency.png | Bin 0 -> 51806 bytes evidence/scaling/summary.csv | 7 + evidence/scaling/throughput.png | Bin 0 -> 53700 bytes evidence/smoke-final.txt | 1 + migrations/README | 1 + migrations/env.py | 60 +++ migrations/script.py.mako | 26 ++ ...89656327_create_initial_database_schema.py | 79 ++++ .../8c3d9f4a21b7_add_idempotency_records.py | 39 ++ requirements.txt | 9 + scripts/analyze-scaling.py | 52 +++ scripts/concurrent-idempotency.py | 40 ++ scripts/load-diagnostic.py | 116 +++++ scripts/restart.sh | 4 + scripts/rolling-update.sh | 46 ++ scripts/run-scaling-experiment.py | 131 ++++++ scripts/stop-one.sh | 17 + scripts/wait-ready.py | 16 + tests/client.py | 2 +- tests/resilience.py | 2 +- 73 files changed, 4507 insertions(+), 26 deletions(-) create mode 100644 Dockerfile create mode 100644 alembic.ini create mode 100644 app/__init__.py create mode 100644 app/api/__init__.py create mode 100644 app/api/auth.py create mode 100644 app/api/chats.py create mode 100644 app/api/deps.py create mode 100644 app/api/messages.py create mode 100644 app/api/users.py create mode 100644 app/core/__init__.py create mode 100644 app/core/config.py create mode 100644 app/db/__init__.py create mode 100644 app/db/base.py create mode 100644 app/db/models.py create mode 100644 app/db/session.py create mode 100644 app/main.py create mode 100644 app/models.py create mode 100644 app/repositories/__init__.py create mode 100644 app/repositories/chat_repository.py create mode 100644 app/repositories/message_repository.py create mode 100644 app/repositories/session_repository.py create mode 100644 app/repositories/user_repository.py create mode 100644 app/services/__init__.py create mode 100644 app/services/auth_service.py create mode 100644 app/services/chat_service.py create mode 100644 app/services/message_service.py create mode 100644 app/services/user_service.py create mode 100644 app/store.py create mode 100644 compose.yaml create mode 100644 evidence/concurrent-1.txt create mode 100644 evidence/concurrent-10.txt create mode 100644 evidence/concurrent-2.txt create mode 100644 evidence/concurrent-3.txt create mode 100644 evidence/concurrent-4.txt create mode 100644 evidence/concurrent-5.txt create mode 100644 evidence/concurrent-6.txt create mode 100644 evidence/concurrent-7.txt create mode 100644 evidence/concurrent-8.txt create mode 100644 evidence/concurrent-9.txt create mode 100644 evidence/concurrent-summary.txt create mode 100644 evidence/failover/replica-1.txt create mode 100644 evidence/failover/replica-2.txt create mode 100644 evidence/rolling-update-diagnostic.json create mode 100644 evidence/rolling-update-final.json create mode 100644 evidence/rolling-update-load.json create mode 100644 evidence/scaling/errors.png create mode 100644 evidence/scaling/expanded_4replicas_2cpu_2048mb.json create mode 100644 evidence/scaling/expanded_4replicas_3cpu_3072mb.json create mode 100644 evidence/scaling/expanded_4replicas_4cpu_4096mb.json create mode 100644 evidence/scaling/fixed_1replicas.json create mode 100644 evidence/scaling/fixed_2replicas.json create mode 100644 evidence/scaling/fixed_4replicas.json create mode 100644 evidence/scaling/p95-latency.png create mode 100644 evidence/scaling/summary.csv create mode 100644 evidence/scaling/throughput.png create mode 100644 evidence/smoke-final.txt create mode 100644 migrations/README create mode 100644 migrations/env.py create mode 100644 migrations/script.py.mako create mode 100644 migrations/versions/21ad89656327_create_initial_database_schema.py create mode 100644 migrations/versions/8c3d9f4a21b7_add_idempotency_records.py create mode 100644 requirements.txt create mode 100644 scripts/analyze-scaling.py create mode 100644 scripts/concurrent-idempotency.py create mode 100644 scripts/load-diagnostic.py create mode 100644 scripts/restart.sh create mode 100644 scripts/rolling-update.sh create mode 100644 scripts/run-scaling-experiment.py create mode 100644 scripts/stop-one.sh create mode 100644 scripts/wait-ready.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..eeed9d1f --- /dev/null +++ b/Dockerfile @@ -0,0 +1,19 @@ +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=5s --timeout=3s --start-period=20s --retries=3 \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)" +CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--timeout-keep-alive", "5", "--timeout-graceful-shutdown", "20"] diff --git a/REPORT.md b/REPORT.md index c2679005..60138c5a 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,350 @@ -# Отчёт — лабораторная 3 +# Отчёт — лабораторная работа №3 +## «Балансировка и отказ API-реплики» -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- **Автор:** Перевалова Виктория +- **Группа:** БПИ2302 +- **Целевая оценка:** 5 +- **Выбранный исследовательский трек:** Track 1 — цена масштабирования -## Запуск из чистого clone +--- -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +## 1. Цель работы -## Архитектура и решения +Цель лабораторной работы — реализовать систему с несколькими взаимозаменяемыми экземплярами API, работающими за единой точкой входа, обеспечить балансировку запросов и сохранение корректности при отказе одной API-реплики. -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Дополнительные задачи: -## Доказательства критериев +- вынести общее состояние за пределы API-контейнеров; +- реализовать общую идемпотентность операций отправки сообщений; +- обеспечить автоматическое исключение недоступных реплик из балансировки; +- проверить восстановление при отказе экземпляров API; +- исследовать влияние количества реплик и доступных ресурсов на производительность системы. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +## 2. Архитектура и принятые решения -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +### 2.1. Общая архитектура -## Эксперименты и отказы +Система построена на Docker Compose и включает следующие компоненты: -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +- **Traefik 3.6** — единая точка входа и балансировщик нагрузки; +- **API × N** — несколько экземпляров приложения на FastAPI; +- **PostgreSQL 16.6** — основное долговременное хранилище; +- **Redis 7.4.2** — общее хранилище сессий и вспомогательных данных; +- **Migrate** — отдельный одноразовый процесс выполнения миграций Alembic. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +Схема взаимодействия: -## Ограничения и следующие шаги +```text + Клиент + | + v + Traefik 3.6 + / \ + v v + API replica 1 API replica 2 + | | + +------+------+ + | + +--------+--------+ + | | + v v + PostgreSQL Redis + (данные) (сессии) +``` -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Все API-реплики используют общие PostgreSQL и Redis. Поэтому состояние пользователя не зависит от конкретного экземпляра приложения. + +API-контейнеры не публикуют порты непосредственно на хост. Внешний доступ осуществляется через Traefik. + +### 2.2. Балансировка + +Traefik распределяет запросы между доступными API-репликами с использованием стратегии Weighted Round Robin. + +Для обнаружения недоступных экземпляров настроена проверка: + +- endpoint: `/health/ready`; +- интервал: 3 секунды; +- timeout: 2 секунды. + +При недоступности реплики балансировщик перестаёт направлять на неё запросы. + +Для наблюдения за экземпляром, обработавшим запрос, API возвращает заголовок `X-Instance-Id`. + +Sticky sessions не используются. + +### 2.3. Хранение данных и миграции + +PostgreSQL является основным источником долговременных данных. Redis используется как общее хранилище сессий и вспомогательное хранилище. + +Миграции выполняются отдельно от API посредством Alembic: + +```bash +alembic upgrade head +``` + +В Docker Compose предусмотрен отдельный одноразовый сервис миграций. API запускается после успешного завершения миграций и проверки готовности PostgreSQL и Redis. + +### 2.4. Идемпотентность + +Для отправки сообщения используется обязательный заголовок `Idempotency-Key`. + +Реализованы следующие сценарии: + +1. Повтор запроса с тем же ключом и тем же содержимым возвращает результат первоначальной операции. +2. Повторное создание сообщения не происходит. +3. Использование того же ключа с другим содержимым приводит к ответу `409 Conflict`. +4. Конкурентные запросы с одинаковым ключом не создают дубликаты. +5. Идемпотентность сохраняется при обработке запросов разными API-репликами. + +## 3. Запуск проекта + +### 3.1. Требования + +Для запуска необходимы: + +- Docker Desktop; +- Docker Compose v2; +- Git. + +### 3.2. Получение проекта + +```bash +git clone https://gitea.privcloud.tech/perevalova/mtusi2026lab3.git +cd mtusi2026lab3 +git checkout solution/lab3-implementation +``` + +### 3.3. Подготовка конфигурации + +```bash +cp .env.example .env +``` + +### 3.4. Проверка и запуск + +```bash +docker compose config --quiet +docker compose up -d --build +docker compose ps +``` + +Для просмотра состояния сервисов: + +```bash +docker compose ps +``` + +Для просмотра журналов: + +```bash +docker compose logs -f +``` + +Единая точка входа приложения: + +```text +http://localhost:8080 +``` + +### 3.5. Остановка + +Без удаления сохранённых данных: + +```bash +docker compose down +``` + +Для намеренного удаления учебных данных вместе с volumes: + +```bash +docker compose down -v +``` + +Последняя команда удаляет данные PostgreSQL и Redis и должна применяться только при необходимости полного сброса стенда. + +## 4. Проверка функциональных требований + +### 4.1. Работа нескольких реплик + +Проверено обращение к API через Traefik с использованием заголовка `X-Instance-Id`. + +Запросы одного пользователя обрабатывались разными экземплярами API без повторной аутентификации. + +Результат: общая сессия доступна независимо от выбранной реплики. Sticky sessions не требуются. + +### 4.2. Проверка идемпотентности + +Проверены: + +- повторная отправка с тем же ключом; +- повтор с изменённым содержимым; +- 10 конкурентных запросов с одним ключом; +- получение истории сообщений после конкурентных запросов. + +Результат: запросы с одинаковым ключом и содержимым возвращают один и тот же результат. Дубликаты сообщений не создаются. + +### 4.3. Проверка отказа API-реплики + +Для проверки использовался сценарий: + +```bash +BASH_EXE="$(cygpath -w "$(command -v bash)")" \ +python tests/resilience.py --mode failover --action-script scripts/stop-one.sh +``` + +Сценарий последовательно проверял отказ каждой реплики. + +| Проверяемая реплика | Успешные записи | Неуспешные попытки | Восстановление | +|---|---:|---:|---:| +| Replica 1 | 83 | 3 | 4,195 с | +| Replica 2 | 87 | 3 | 4,051 с | + +В обоих случаях проверка завершилась успешно. + +Результаты сохранены: + +- `evidence/failover/replica-1.txt`; +- `evidence/failover/replica-2.txt`. + +Время восстановления в обоих сценариях не превысило 10 секунд. + +### 4.4. Проверка rolling update + +Для последовательной замены API-реплик реализован скрипт: + +```bash +bash scripts/rolling-update.sh +``` + +Скрипт выполняет следующие действия: + +1. Создаёт новую реплику. +2. Ожидает её готовности. +3. Переводит старую реплику в состояние drain. +4. Ожидает прекращения направления новых запросов. +5. Останавливает старую реплику. +6. Повторяет процесс для следующего экземпляра. + +Для проверки использовалась нагрузка с восемью параллельными клиентами в течение примерно 90 секунд. + +Последний диагностический запуск: + +| Метрика | Результат | +|---|---:| +| Длительность | 91,245 с | +| Параллельные клиенты | 8 | +| Успешные запросы | 6050 | +| Неуспешные запросы | 20 | +| Доля ошибок | 0,3295% | +| Успешный RPS | 66,305 | +| p50 | 87,748 мс | +| p95 | 280,709 мс | +| p99 | 427,002 мс | + +Все зарегистрированные ошибки в последнем запуске — HTTP 502. Тайм-аутов в этом запуске не зафиксировано. + +По сравнению с предыдущим диагностическим запуском число ошибок уменьшилось с 22 до 20, а тайм-ауты исчезли. Однако полностью устранить кратковременные HTTP 502 пока не удалось. + +Поэтому rolling update считается реализованным и проверенным под нагрузкой, но не безошибочным. + +## 5. Исследовательский трек 1. Цена масштабирования + +### 5.1. Цель эксперимента + +Исследовать влияние количества API-реплик на производительность системы при фиксированном суммарном объёме ресурсов. + +Гипотеза: увеличение количества реплик повышает пропускную способность, но эффект масштабирования постепенно уменьшается из-за общих инфраструктурных компонентов. + +После сравнения количества реплик проводится дополнительная серия с увеличением доступных CPU и RAM. + +### 5.2. Методика + +В первой серии сравнивались 1, 2 и 4 API-реплики при одинаковом суммарном бюджете: + +- CPU: 2; +- RAM: 2048 MB. + +Во второй серии использовались 4 API-реплики, а доступные ресурсы увеличивались. + +Результаты экспериментов сохранены в каталоге `evidence/scaling/`, включая исходные JSON, сводную таблицу и графики. + +### 5.3. Сравнение количества реплик + +| Конфигурация | RPS | p95, мс | Ошибки | +|---|---:|---:|---:| +| 1 реплика | 37,541 | 302,388 | 0 | +| 2 реплики | 59,211 | 294,656 | 0 | +| 4 реплики | 65,877 | 390,895 | 0 | + +При переходе от одной реплики к двум пропускная способность выросла примерно на 57,7%. + +При переходе от двух реплик к четырём прирост составил около 11,3%. + +Это демонстрирует снижение эффективности дальнейшего горизонтального масштабирования при неизменном суммарном бюджете ресурсов. + +### 5.4. Серия с увеличением ресурсов + +| API-реплики | CPU | RAM, MB | RPS | p95, мс | +|---|---:|---:|---:|---:| +| 4 | 2 | 2048 | 68,467 | 374,351 | +| 4 | 3 | 3072 | 95,214 | 238,599 | +| 4 | 4 | 4096 | 119,589 | 137,459 | + +При увеличении ресурсов с 2 CPU / 2048 MB до 4 CPU / 4096 MB пропускная способность выросла примерно на 74,7%. + +Значение p95 latency уменьшилось примерно на 63,3%. + +### 5.5. Выводы по эксперименту + +Эксперимент показал, что горизонтальное масштабирование при фиксированном суммарном объёме ресурсов имеет убывающую отдачу. + +Увеличение количества реплик с одной до двух существенно повышает пропускную способность. Переход от двух к четырём репликам даёт значительно меньший прирост и сопровождается увеличением p95 latency. + +Дополнительное увеличение CPU и RAM при четырёх репликах улучшило пропускную способность и задержки. + +При этом точка насыщения PostgreSQL, Traefik или пула соединений не была однозначно локализована: для такого вывода необходимы отдельные измерения загрузки БД, ожидания соединений, CPU балансировщика и состояния пула. + +Следовательно, эксперимент подтверждает влияние количества реплик и доступных ресурсов на производительность, но не позволяет достоверно приписать снижение эффективности конкретному компоненту. + +## 6. Итоговая проверка критериев + +| Требование | Результат | Доказательство | +|---|---|---| +| Не менее двух API-реплик | Выполнено | `docker compose ps` | +| Единая точка входа | Выполнено | Traefik, порт 8080 | +| Общая PostgreSQL и Redis | Выполнено | `compose.yaml` | +| Разные `X-Instance-Id` | Проверено | Результаты функциональных проверок | +| Отсутствие sticky sessions | Выполнено | Общая сессия между репликами | +| Обязательный `Idempotency-Key` | Проверено | Конкурентные тесты | +| Readiness и healthcheck | Выполнено | `/health/ready`, Docker healthcheck | +| Отказ каждой API-реплики | PASS | `evidence/failover/` | +| Восстановление не более 10 секунд | PASS | 4,195 и 4,051 секунды | +| CPU/RAM limits | Выполнено | `compose.yaml` | +| API-порты не опубликованы | Выполнено | `docker compose ps` | +| Однократные миграции | Выполнено | Сервис `migrate` | +| Rolling update под нагрузкой | Выполнено с ограничением | `evidence/rolling-update-final.json` | +| Сравнение 1/2/4 реплик | Выполнено | `evidence/scaling/summary.csv` | +| Серия увеличения ресурсов | Выполнено | `evidence/scaling/` | +| Локализация saturation point | Не подтверждена | Требуется дополнительная телеметрия | + +## 7. Ограничения реализации + +1. Rolling update пока сопровождается небольшим количеством кратковременных HTTP 502. Поэтому нельзя утверждать, что замена реплик полностью бесшовна. +2. Точка насыщения БД, балансировщика или пула соединений экспериментально не локализована. +3. Стенд работает на одном Docker host. Отказ всего хоста не покрывается данной архитектурой. +4. PostgreSQL и Traefik остаются отдельными потенциальными точками отказа. +5. Результаты производительности относятся к конкретному окружению и не являются универсальными характеристиками приложения. + +Для дальнейшего улучшения необходимо исследовать метрики PostgreSQL и пула соединений, дополнительно настроить drain и проверку состояния backend перед остановкой старого экземпляра, а также рассмотреть отказоустойчивость самой БД и балансировщика. + +## 8. Заключение + +В лабораторной работе реализована система с несколькими API-репликами, общей базой данных, общим хранилищем сессий и балансировщиком Traefik. + +Проверены распределение запросов между репликами, сохранение сессии, общая идемпотентность, конкурентные запросы и восстановление после остановки каждой API-реплики. + +Время восстановления в двух сценариях отказа составило около четырёх секунд, что укладывается в установленный предел 10 секунд. + +В рамках исследовательского трека выполнено сравнение одной, двух и четырёх API-реплик при фиксированном бюджете ресурсов, а также серия экспериментов с увеличением CPU и RAM. Полученные результаты показали убывающую отдачу от горизонтального масштабирования и положительное влияние увеличения ресурсов на пропускную способность. + +Таким образом, основные механизмы балансировки, отказоустойчивости и масштабирования реализованы и проверены. При этом ограничения rolling update и отсутствие однозначно установленной точки насыщения инфраструктурных компонентов явно зафиксированы, а не скрыты в итоговых выводах. \ No newline at end of file diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 00000000..421e3fe9 --- /dev/null +++ b/alembic.ini @@ -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 diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/api/__init__.py b/app/api/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/api/auth.py b/app/api/auth.py new file mode 100644 index 00000000..bea835c4 --- /dev/null +++ b/app/api/auth.py @@ -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 diff --git a/app/api/chats.py b/app/api/chats.py new file mode 100644 index 00000000..40c46261 --- /dev/null +++ b/app/api/chats.py @@ -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 diff --git a/app/api/deps.py b/app/api/deps.py new file mode 100644 index 00000000..6c695862 --- /dev/null +++ b/app/api/deps.py @@ -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 diff --git a/app/api/messages.py b/app/api/messages.py new file mode 100644 index 00000000..9b642345 --- /dev/null +++ b/app/api/messages.py @@ -0,0 +1,73 @@ +import re +import uuid + +from fastapi import APIRouter, Depends, Header, 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, + IdempotencyConflictError, +) + +router = APIRouter(prefix="/api/v1/chats/{chat_id}/messages", tags=["Messages"]) +IDEMPOTENCY_KEY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$") + + +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, + idempotency_key: str = Header(..., alias="Idempotency-Key", min_length=1, max_length=128), + db: Session = Depends(get_db), + user: UserModel = Depends(get_current_user), +): + if not IDEMPOTENCY_KEY_RE.fullmatch(idempotency_key): + raise HTTPException(status_code=400, detail="Invalid Idempotency-Key") + parsed_id = parse_chat_id(chat_id) + try: + message = MessageService(db).create_message( + chat_id=parsed_id, sender_id=user.id, text=body.text, + idempotency_key=idempotency_key, + ) + 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 + except IdempotencyConflictError: + raise HTTPException(status_code=409, detail="Idempotency-Key was already used with a different request") 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 diff --git a/app/api/users.py b/app/api/users.py new file mode 100644 index 00000000..67adc7c6 --- /dev/null +++ b/app/api/users.py @@ -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) diff --git a/app/core/__init__.py b/app/core/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/core/config.py b/app/core/config.py new file mode 100644 index 00000000..ec78b7be --- /dev/null +++ b/app/core/config.py @@ -0,0 +1,24 @@ +import os +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@postgres:5432/messenger" + db_pool_size: int = 5 + db_max_overflow: int = 5 + db_pool_timeout: int = 10 + session_ttl_seconds: int = 3600 + cache_url: str = "redis://redis:6379/0" + message_cache_ttl_seconds: int = 60 + idempotency_ttl_seconds: int = 86400 + instance_id: str = os.getenv("INSTANCE_ID") or os.getenv("HOSTNAME") or "api-local" + shutdown_grace_seconds: int = 20 + + model_config = SettingsConfigDict( + env_file=".env", env_file_encoding="utf-8", extra="ignore" + ) + + +settings = Settings() diff --git a/app/db/__init__.py b/app/db/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/db/base.py b/app/db/base.py new file mode 100644 index 00000000..1c2dcc40 --- /dev/null +++ b/app/db/base.py @@ -0,0 +1,5 @@ +from sqlalchemy.orm import DeclarativeBase + + +class Base(DeclarativeBase): + pass \ No newline at end of file diff --git a/app/db/models.py b/app/db/models.py new file mode 100644 index 00000000..772fdcff --- /dev/null +++ b/app/db/models.py @@ -0,0 +1,215 @@ +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() + +class IdempotencyRecord(Base): + __tablename__ = "idempotency_records" + + id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), primary_key=True, default=uuid.uuid4 + ) + user_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False + ) + method: Mapped[str] = mapped_column(String(10), nullable=False) + path: Mapped[str] = mapped_column(String(255), nullable=False) + idempotency_key: Mapped[str] = mapped_column(String(128), nullable=False) + request_hash: Mapped[str] = mapped_column(String(64), nullable=False) + # NULL is visible only inside the creating transaction; the message and + # idempotency row are committed atomically. + message_id: Mapped[uuid.UUID | None] = mapped_column( + UUID(as_uuid=True), ForeignKey("messages.id", ondelete="CASCADE"), nullable=True + ) + created_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), default=utc_now, nullable=False + ) + expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + + __table_args__ = ( + UniqueConstraint( + "user_id", "method", "path", "idempotency_key", + name="uq_idempotency_scope_key", + ), + Index("ix_idempotency_records_expires_at", "expires_at"), + ) diff --git a/app/db/session.py b/app/db/session.py new file mode 100644 index 00000000..190589bd --- /dev/null +++ b/app/db/session.py @@ -0,0 +1,15 @@ +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=settings.db_pool_size, + max_overflow=settings.db_max_overflow, + pool_timeout=settings.db_pool_timeout, + pool_recycle=1800, +) + +SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False) diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..32fc2746 --- /dev/null +++ b/app/main.py @@ -0,0 +1,86 @@ +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 pathlib import Path +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 instance_id=%s", settings.instance_id) + try: + yield + finally: + engine.dispose() + logger.info("Application shutdown instance_id=%s", settings.instance_id) + +app = FastAPI(title=settings.app_name, version="1.3.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 response_headers(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 + response.headers["X-Instance-Id"] = settings.instance_id + response.headers["X-Content-Type-Options"] = "nosniff" + return response + +@app.exception_handler(HTTPException) +async def http_exception_handler(request: Request, exc: HTTPException): + request_id = getattr(request.state, "request_id", str(uuid.uuid4())) + code = {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"}.get(exc.status_code, "internal_error") + headers = dict(exc.headers or {}) + headers["X-Request-Id"] = request_id + headers["X-Instance-Id"] = settings.instance_id + return JSONResponse(status_code=exc.status_code, content={"error": {"code": code, "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 = getattr(request.state, "request_id", str(uuid.uuid4())) + return JSONResponse(status_code=400, content={"error": {"code": "invalid_request", "message": "Validation error", "request_id": request_id}}, headers={"X-Request-Id": request_id, "X-Instance-Id": settings.instance_id}) + +@app.get("/health/live") +def liveness(): + return {"status": "ok"} + +DRAIN_FILE = Path("/tmp/api-draining") +@app.get("/health/ready") +def readiness(): + if DRAIN_FILE.exists(): + raise HTTPException( + status_code=503, + detail="Instance is draining", + ) + + 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 diff --git a/app/models.py b/app/models.py new file mode 100644 index 00000000..ace6808f --- /dev/null +++ b/app/models.py @@ -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 diff --git a/app/repositories/__init__.py b/app/repositories/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/repositories/chat_repository.py b/app/repositories/chat_repository.py new file mode 100644 index 00000000..e5cd838e --- /dev/null +++ b/app/repositories/chat_repository.py @@ -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 \ No newline at end of file diff --git a/app/repositories/message_repository.py b/app/repositories/message_repository.py new file mode 100644 index 00000000..6698ed1d --- /dev/null +++ b/app/repositories/message_repository.py @@ -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()) \ No newline at end of file diff --git a/app/repositories/session_repository.py b/app/repositories/session_repository.py new file mode 100644 index 00000000..7366b170 --- /dev/null +++ b/app/repositories/session_repository.py @@ -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 \ No newline at end of file diff --git a/app/repositories/user_repository.py b/app/repositories/user_repository.py new file mode 100644 index 00000000..4569dcd1 --- /dev/null +++ b/app/repositories/user_repository.py @@ -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 \ No newline at end of file diff --git a/app/services/__init__.py b/app/services/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/services/auth_service.py b/app/services/auth_service.py new file mode 100644 index 00000000..e459ddf3 --- /dev/null +++ b/app/services/auth_service.py @@ -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 diff --git a/app/services/chat_service.py b/app/services/chat_service.py new file mode 100644 index 00000000..10ff5656 --- /dev/null +++ b/app/services/chat_service.py @@ -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) diff --git a/app/services/message_service.py b/app/services/message_service.py new file mode 100644 index 00000000..381da242 --- /dev/null +++ b/app/services/message_service.py @@ -0,0 +1,418 @@ +import base64 +import hashlib +import json +import time +import uuid +from datetime import datetime, timedelta, timezone +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 import delete, select, update +from sqlalchemy.dialects.postgresql import insert as pg_insert +from sqlalchemy.orm import Session + +from app.core.config import settings +from app.db.models import IdempotencyRecord, 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 IdempotencyConflictError(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, + idempotency_key: str, + ) -> Message: + text = text.strip() + if not text or len(text) > 4000: + raise InvalidMessageDataError("Invalid message text") + + # Access is checked for every retry, before consulting the key. + if not self.chats.is_member(chat_id, sender_id): + raise MessageNotFoundError() + + method = "POST" + path = f"/api/v1/chats/{chat_id}/messages" + request_hash = hashlib.sha256( + json.dumps({"text": text}, sort_keys=True, separators=(",", ":")).encode("utf-8") + ).hexdigest() + now = datetime.now(timezone.utc) + expires_at = now + timedelta(seconds=max(settings.idempotency_ttl_seconds, 86400)) + scope = ( + IdempotencyRecord.user_id == sender_id, + IdempotencyRecord.method == method, + IdempotencyRecord.path == path, + IdempotencyRecord.idempotency_key == idempotency_key, + ) + + try: + # An expired key may be reused. Deletion and claim are serialized by + # PostgreSQL's unique constraint for the scope. + self.db.execute( + delete(IdempotencyRecord).where(*scope, IdempotencyRecord.expires_at <= now) + ) + claim = ( + pg_insert(IdempotencyRecord) + .values( + id=uuid.uuid4(), user_id=sender_id, method=method, path=path, + idempotency_key=idempotency_key, request_hash=request_hash, + message_id=None, created_at=now, expires_at=expires_at, + ) + .on_conflict_do_nothing(constraint="uq_idempotency_scope_key") + .returning(IdempotencyRecord.id) + ) + claimed_id = self.db.execute(claim).scalar_one_or_none() + + if claimed_id is None: + existing = self.db.execute( + select(IdempotencyRecord).where(*scope).with_for_update() + ).scalar_one_or_none() + if existing is None: + # Rare expiration race: retry once in a fresh transaction. + self.db.rollback() + return self.create_message(chat_id, sender_id, text, idempotency_key) + if existing.request_hash != request_hash: + self.db.rollback() + raise IdempotencyConflictError() + if existing.message_id is None: + raise RuntimeError("Committed idempotency record has no message") + message = self.db.get(Message, existing.message_id) + if message is None: + raise RuntimeError("Idempotency record references a missing message") + self.db.commit() + return message + + message = self.messages.create( + chat_id=chat_id, sender_id=sender_id, text=text + ) + self.db.execute( + update(IdempotencyRecord) + .where(IdempotencyRecord.id == claimed_id) + .values(message_id=message.id) + ) + self.db.commit() + self.db.refresh(message) + self._bump_version(chat_id) + return message + except IdempotencyConflictError: + raise + 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 diff --git a/app/services/user_service.py b/app/services/user_service.py new file mode 100644 index 00000000..896ee5ec --- /dev/null +++ b/app/services/user_service.py @@ -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, + ) \ No newline at end of file diff --git a/app/store.py b/app/store.py new file mode 100644 index 00000000..4802821c --- /dev/null +++ b/app/store.py @@ -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 diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..44f48cf9 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,143 @@ +name: mtusi-lab3 +services: + postgres: + image: postgres:16.6-bookworm + restart: unless-stopped + environment: + POSTGRES_DB: ${POSTGRES_DB:-messenger} + POSTGRES_USER: ${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: 15 + start_period: 10s + deploy: + resources: + limits: + cpus: "${POSTGRES_CPU_LIMIT:-1.0}" + memory: ${POSTGRES_MEMORY_LIMIT:-768M} + networks: [backend] + + redis: + image: redis:7.4.2-bookworm + restart: unless-stopped + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"] + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + deploy: + resources: + limits: + cpus: "${REDIS_CPU_LIMIT:-0.5}" + memory: ${REDIS_MEMORY_LIMIT:-256M} + networks: [backend] + + migrate: + build: + context: . + dockerfile: Dockerfile + command: ["alembic", "upgrade", "head"] + environment: + DATABASE_URL: postgresql+psycopg://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-messenger} + depends_on: + postgres: + condition: service_healthy + restart: "no" + networks: [backend] + + api: + build: + context: . + dockerfile: Dockerfile + restart: unless-stopped + environment: + APP_ENV: ${APP_ENV:-lab} + DATABASE_URL: postgresql+psycopg://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-messenger} + CACHE_URL: redis://redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + MESSAGE_CACHE_TTL_SECONDS: ${MESSAGE_CACHE_TTL_SECONDS:-60} + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + DB_POOL_SIZE: ${DB_POOL_SIZE:-3} + DB_MAX_OVERFLOW: ${DB_MAX_OVERFLOW:-2} + DB_POOL_TIMEOUT: ${DB_POOL_TIMEOUT:-10} + SHUTDOWN_GRACE_SECONDS: ${SHUTDOWN_GRACE_SECONDS:-20} + depends_on: + migrate: + condition: service_completed_successfully + postgres: + condition: service_healthy + redis: + condition: service_healthy + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"] + interval: 5s + timeout: 3s + retries: 3 + start_period: 20s + deploy: + resources: + limits: + cpus: "${API_CPU_LIMIT:-1.0}" + memory: ${API_MEMORY_LIMIT:-512M} + labels: + - traefik.enable=true + - traefik.docker.network=mtusi-lab3-edge + - traefik.http.routers.messenger.rule=PathPrefix(`/`) + - traefik.http.routers.messenger.entrypoints=web + - traefik.http.services.messenger.loadbalancer.server.port=8080 + - traefik.http.services.messenger.loadbalancer.healthcheck.path=/health/ready + - traefik.http.services.messenger.loadbalancer.healthcheck.interval=3s + - traefik.http.services.messenger.loadbalancer.healthcheck.timeout=2s + - traefik.http.services.messenger.loadbalancer.passhostheader=true + - traefik.http.services.messenger.loadbalancer.responseforwarding.flushinterval=100ms + networks: [backend, edge] + + traefik: + image: traefik:v3.6 + restart: unless-stopped + environment: + DOCKER_API_VERSION: "1.44" + command: + - --providers.docker=true + - --providers.docker.exposedbydefault=false + - --providers.docker.network=mtusi-lab3-edge + - --entrypoints.web.address=:8080 + - --ping=true + - --ping.entrypoint=ping + - --entrypoints.ping.address=:8082 + - --accesslog=true + - --log.level=DEBUG + ports: + - "8080:8080" + volumes: + - /var/run/docker.sock:/var/run/docker.sock:ro + healthcheck: + test: ["CMD", "wget", "-q", "--spider", "http://127.0.0.1:8082/ping"] + interval: 10s + timeout: 3s + retries: 5 + deploy: + resources: + limits: + cpus: "${LB_CPU_LIMIT:-0.5}" + memory: ${LB_MEMORY_LIMIT:-256M} + networks: [edge] + +networks: + backend: + driver: bridge + edge: + name: mtusi-lab3-edge + driver: bridge + +volumes: + postgres_data: + redis_data: diff --git a/evidence/concurrent-1.txt b/evidence/concurrent-1.txt new file mode 100644 index 00000000..cd69ab4e --- /dev/null +++ b/evidence/concurrent-1.txt @@ -0,0 +1,2 @@ +{"id":"ba491f27-f3d7-47ab-abb0-547768c2c308","chat_id":"822c8e51-885a-43c0-9419-754081666a37","sender_id":"6234d398-4141-4830-9e3f-47b2df8a5642","text":"Concurrent idempotency test","created_at":"2026-11-05T13:39:39.066506Z"} +HTTP_STATUS:201 diff --git a/evidence/concurrent-10.txt b/evidence/concurrent-10.txt new file mode 100644 index 00000000..cd69ab4e --- /dev/null +++ b/evidence/concurrent-10.txt @@ -0,0 +1,2 @@ +{"id":"ba491f27-f3d7-47ab-abb0-547768c2c308","chat_id":"822c8e51-885a-43c0-9419-754081666a37","sender_id":"6234d398-4141-4830-9e3f-47b2df8a5642","text":"Concurrent idempotency test","created_at":"2026-11-05T13:39:39.066506Z"} +HTTP_STATUS:201 diff --git a/evidence/concurrent-2.txt b/evidence/concurrent-2.txt new file mode 100644 index 00000000..cd69ab4e --- /dev/null +++ b/evidence/concurrent-2.txt @@ -0,0 +1,2 @@ +{"id":"ba491f27-f3d7-47ab-abb0-547768c2c308","chat_id":"822c8e51-885a-43c0-9419-754081666a37","sender_id":"6234d398-4141-4830-9e3f-47b2df8a5642","text":"Concurrent idempotency test","created_at":"2026-11-05T13:39:39.066506Z"} +HTTP_STATUS:201 diff --git a/evidence/concurrent-3.txt b/evidence/concurrent-3.txt new file mode 100644 index 00000000..cd69ab4e --- /dev/null +++ b/evidence/concurrent-3.txt @@ -0,0 +1,2 @@ +{"id":"ba491f27-f3d7-47ab-abb0-547768c2c308","chat_id":"822c8e51-885a-43c0-9419-754081666a37","sender_id":"6234d398-4141-4830-9e3f-47b2df8a5642","text":"Concurrent idempotency test","created_at":"2026-11-05T13:39:39.066506Z"} +HTTP_STATUS:201 diff --git a/evidence/concurrent-4.txt b/evidence/concurrent-4.txt new file mode 100644 index 00000000..cd69ab4e --- /dev/null +++ b/evidence/concurrent-4.txt @@ -0,0 +1,2 @@ +{"id":"ba491f27-f3d7-47ab-abb0-547768c2c308","chat_id":"822c8e51-885a-43c0-9419-754081666a37","sender_id":"6234d398-4141-4830-9e3f-47b2df8a5642","text":"Concurrent idempotency test","created_at":"2026-11-05T13:39:39.066506Z"} +HTTP_STATUS:201 diff --git a/evidence/concurrent-5.txt b/evidence/concurrent-5.txt new file mode 100644 index 00000000..cd69ab4e --- /dev/null +++ b/evidence/concurrent-5.txt @@ -0,0 +1,2 @@ +{"id":"ba491f27-f3d7-47ab-abb0-547768c2c308","chat_id":"822c8e51-885a-43c0-9419-754081666a37","sender_id":"6234d398-4141-4830-9e3f-47b2df8a5642","text":"Concurrent idempotency test","created_at":"2026-11-05T13:39:39.066506Z"} +HTTP_STATUS:201 diff --git a/evidence/concurrent-6.txt b/evidence/concurrent-6.txt new file mode 100644 index 00000000..cd69ab4e --- /dev/null +++ b/evidence/concurrent-6.txt @@ -0,0 +1,2 @@ +{"id":"ba491f27-f3d7-47ab-abb0-547768c2c308","chat_id":"822c8e51-885a-43c0-9419-754081666a37","sender_id":"6234d398-4141-4830-9e3f-47b2df8a5642","text":"Concurrent idempotency test","created_at":"2026-11-05T13:39:39.066506Z"} +HTTP_STATUS:201 diff --git a/evidence/concurrent-7.txt b/evidence/concurrent-7.txt new file mode 100644 index 00000000..cd69ab4e --- /dev/null +++ b/evidence/concurrent-7.txt @@ -0,0 +1,2 @@ +{"id":"ba491f27-f3d7-47ab-abb0-547768c2c308","chat_id":"822c8e51-885a-43c0-9419-754081666a37","sender_id":"6234d398-4141-4830-9e3f-47b2df8a5642","text":"Concurrent idempotency test","created_at":"2026-11-05T13:39:39.066506Z"} +HTTP_STATUS:201 diff --git a/evidence/concurrent-8.txt b/evidence/concurrent-8.txt new file mode 100644 index 00000000..cd69ab4e --- /dev/null +++ b/evidence/concurrent-8.txt @@ -0,0 +1,2 @@ +{"id":"ba491f27-f3d7-47ab-abb0-547768c2c308","chat_id":"822c8e51-885a-43c0-9419-754081666a37","sender_id":"6234d398-4141-4830-9e3f-47b2df8a5642","text":"Concurrent idempotency test","created_at":"2026-11-05T13:39:39.066506Z"} +HTTP_STATUS:201 diff --git a/evidence/concurrent-9.txt b/evidence/concurrent-9.txt new file mode 100644 index 00000000..cd69ab4e --- /dev/null +++ b/evidence/concurrent-9.txt @@ -0,0 +1,2 @@ +{"id":"ba491f27-f3d7-47ab-abb0-547768c2c308","chat_id":"822c8e51-885a-43c0-9419-754081666a37","sender_id":"6234d398-4141-4830-9e3f-47b2df8a5642","text":"Concurrent idempotency test","created_at":"2026-11-05T13:39:39.066506Z"} +HTTP_STATUS:201 diff --git a/evidence/concurrent-summary.txt b/evidence/concurrent-summary.txt new file mode 100644 index 00000000..5744702b --- /dev/null +++ b/evidence/concurrent-summary.txt @@ -0,0 +1,5 @@ +]633;E;{ echo "Concurrent idempotency test"\x3b echo "Requests: 10"\x3b echo "Expected HTTP status: 201"\x3b echo "Expected unique message ID: ba491f27-f3d7-47ab-abb0-547768c2c308"\x3b echo "Result: PASS"\x3b } > evidence/concurrent-summary.txt;4eb7bf5d-580a-40d0-b860-fce765fce5ff]633;CConcurrent idempotency test +Requests: 10 +Expected HTTP status: 201 +Expected unique message ID: ba491f27-f3d7-47ab-abb0-547768c2c308 +Result: PASS diff --git a/evidence/failover/replica-1.txt b/evidence/failover/replica-1.txt new file mode 100644 index 00000000..fce488af --- /dev/null +++ b/evidence/failover/replica-1.txt @@ -0,0 +1,3 @@ +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 83, "failed_attempts": 3, "first_recovery_seconds": 4.195} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/failover/replica-2.txt b/evidence/failover/replica-2.txt new file mode 100644 index 00000000..1187be3b --- /dev/null +++ b/evidence/failover/replica-2.txt @@ -0,0 +1,3 @@ +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 87, "failed_attempts": 3, "first_recovery_seconds": 4.051} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/rolling-update-diagnostic.json b/evidence/rolling-update-diagnostic.json new file mode 100644 index 00000000..1e0ae3c3 --- /dev/null +++ b/evidence/rolling-update-diagnostic.json @@ -0,0 +1,42 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "duration_seconds": 91.64, + "concurrency": 8, + "successful_requests": 5694, + "failed_requests": 22, + "error_ratio": 0.003849, + "errors_by_type": { + "http_502": 14, + "connection_TimeoutError": 8 + }, + "successful_rps": 62.135, + "successful_latency_ms": { + "p50": 111.668, + "p95": 267.403, + "p99": 393.579 + }, + "error_examples": [ + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: connection/TLS failure (TimeoutError)", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: connection/TLS failure (TimeoutError)", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: connection/TLS failure (TimeoutError)", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: connection/TLS failure (TimeoutError)", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: connection/TLS failure (TimeoutError)", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: expected [201], received 502", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: connection/TLS failure (TimeoutError)", + "POST /api/v1/chats/6875e847-fc8c-476e-966f-25eabb4f209e/messages: connection/TLS failure (TimeoutError)" + ], + "note": "Latency percentiles cover successful requests only." +} diff --git a/evidence/rolling-update-final.json b/evidence/rolling-update-final.json new file mode 100644 index 00000000..4fbb7612 --- /dev/null +++ b/evidence/rolling-update-final.json @@ -0,0 +1,41 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "duration_seconds": 91.245, + "concurrency": 8, + "successful_requests": 6050, + "failed_requests": 20, + "error_ratio": 0.003295, + "errors_by_type": { + "http_502": 20 + }, + "successful_rps": 66.305, + "successful_latency_ms": { + "p50": 87.748, + "p95": 280.709, + "p99": 427.002 + }, + "error_examples": [ + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502", + "POST /api/v1/chats/63292225-703b-4944-b89b-3c916e925743/messages: expected [201], received 502" + ], + "note": "Latency percentiles cover successful requests only." +} diff --git a/evidence/rolling-update-load.json b/evidence/rolling-update-load.json new file mode 100644 index 00000000..f902bd44 --- /dev/null +++ b/evidence/rolling-update-load.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 90.0, + "elapsed_seconds": 91.541, + "concurrency": 8, + "successful_requests": 5205, + "failed_requests": 51, + "error_ratio": 0.009703, + "successful_rps": 56.86, + "successful_latency_ms": { + "p50": 110.445, + "p95": 271.578, + "p99": 413.327 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scaling/errors.png b/evidence/scaling/errors.png new file mode 100644 index 0000000000000000000000000000000000000000..f96137a2ec812fd18d4cc946a2369028f139f2f5 GIT binary patch literal 51152 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

$yvRNrG!7U8^J={C0%cJqRAB~^@E(ngs{c= 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 z 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 literal 0 HcmV?d00001 diff --git a/evidence/scaling/expanded_4replicas_2cpu_2048mb.json b/evidence/scaling/expanded_4replicas_2cpu_2048mb.json new file mode 100644 index 00000000..e262efb3 --- /dev/null +++ b/evidence/scaling/expanded_4replicas_2cpu_2048mb.json @@ -0,0 +1,194 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.686, + "concurrency": 8, + "successful_requests": 2101, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 68.467, + "successful_latency_ms": { + "p50": 50.668, + "p95": 374.351, + "p99": 489.573 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.", + "scenario": "expanded_4replicas_2cpu_2048mb", + "api_replicas": 4, + "total_api_cpu_budget": 2.0, + "total_api_memory_budget_mb": 2048, + "per_replica_cpu_limit": 0.5, + "per_replica_memory_limit_mb": 512, + "container_stats_samples": [ + { + "timestamp_epoch": 1793886504.0991633, + "containers": [ + "mtusi-lab3-api-4;15.64%;68.37MiB / 512MiB", + "mtusi-lab3-api-3;18.83%;68.32MiB / 512MiB", + "mtusi-lab3-api-1;19.08%;68.34MiB / 512MiB", + "mtusi-lab3-api-2;0.71%;69.18MiB / 512MiB", + "mtusi-lab3-postgres-1;0.55%;26.86MiB / 768MiB", + "mtusi-lab3-redis-1;0.30%;3.531MiB / 256MiB", + "mtusi-lab3-traefik-1;0.55%;17.91MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.24%;3.621MiB / 7.622GiB", + "artship-frontend;12.05%;90.32MiB / 7.622GiB", + "artship-backend;1.38%;198.8MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,10,100" + }, + { + "timestamp_epoch": 1793886507.5500882, + "containers": [ + "mtusi-lab3-api-4;30.50%;70.11MiB / 512MiB", + "mtusi-lab3-api-3;28.82%;68.95MiB / 512MiB", + "mtusi-lab3-api-1;48.19%;69.97MiB / 512MiB", + "mtusi-lab3-api-2;40.97%;70.31MiB / 512MiB", + "mtusi-lab3-postgres-1;24.12%;46.57MiB / 768MiB", + "mtusi-lab3-redis-1;7.09%;3.648MiB / 256MiB", + "mtusi-lab3-traefik-1;8.94%;18.37MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.20%;3.621MiB / 7.622GiB", + "artship-frontend;9.85%;90.21MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,19,100" + }, + { + "timestamp_epoch": 1793886510.967673, + "containers": [ + "mtusi-lab3-api-4;34.44%;70.19MiB / 512MiB", + "mtusi-lab3-api-3;33.16%;69.07MiB / 512MiB", + "mtusi-lab3-api-1;49.41%;70.35MiB / 512MiB", + "mtusi-lab3-api-2;37.62%;70.42MiB / 512MiB", + "mtusi-lab3-postgres-1;27.40%;49.12MiB / 768MiB", + "mtusi-lab3-redis-1;7.85%;3.645MiB / 256MiB", + "mtusi-lab3-traefik-1;12.22%;23.12MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.34%;3.621MiB / 7.622GiB", + "artship-frontend;14.85%;90.36MiB / 7.622GiB", + "artship-backend;282.30%;153.4MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,19,100" + }, + { + "timestamp_epoch": 1793886514.6916337, + "containers": [ + "mtusi-lab3-api-4;33.50%;70.3MiB / 512MiB", + "mtusi-lab3-api-3;32.53%;69.73MiB / 512MiB", + "mtusi-lab3-api-1;32.08%;70.41MiB / 512MiB", + "mtusi-lab3-api-2;49.22%;71.13MiB / 512MiB", + "mtusi-lab3-postgres-1;27.65%;51.22MiB / 768MiB", + "mtusi-lab3-redis-1;6.18%;3.656MiB / 256MiB", + "mtusi-lab3-traefik-1;13.40%;24.93MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.28%;3.621MiB / 7.622GiB", + "artship-frontend;9.34%;90.95MiB / 7.622GiB", + "artship-backend;6.52%;198.7MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "3,20,100" + }, + { + "timestamp_epoch": 1793886518.2727063, + "containers": [ + "mtusi-lab3-api-4;43.58%;79.84MiB / 512MiB", + "mtusi-lab3-api-3;29.50%;70.04MiB / 512MiB", + "mtusi-lab3-api-1;32.03%;70.45MiB / 512MiB", + "mtusi-lab3-api-2;48.82%;71.34MiB / 512MiB", + "mtusi-lab3-postgres-1;25.93%;49.01MiB / 768MiB", + "mtusi-lab3-redis-1;6.90%;3.645MiB / 256MiB", + "mtusi-lab3-traefik-1;13.53%;25.2MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.25%;3.621MiB / 7.622GiB", + "artship-frontend;8.48%;90.53MiB / 7.622GiB", + "artship-backend;0.19%;191MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,19,100" + }, + { + "timestamp_epoch": 1793886521.316862, + "containers": [ + "mtusi-lab3-api-4;28.95%;70.8MiB / 512MiB", + "mtusi-lab3-api-3;27.79%;69.83MiB / 512MiB", + "mtusi-lab3-api-1;51.05%;70.98MiB / 512MiB", + "mtusi-lab3-api-2;28.37%;71.39MiB / 512MiB", + "mtusi-lab3-postgres-1;29.36%;52.06MiB / 768MiB", + "mtusi-lab3-redis-1;6.88%;3.66MiB / 256MiB", + "mtusi-lab3-traefik-1;13.06%;25.26MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.29%;3.621MiB / 7.622GiB", + "artship-frontend;13.07%;91.4MiB / 7.622GiB", + "artship-backend;191.35%;218.3MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,20,100" + }, + { + "timestamp_epoch": 1793886524.8557577, + "containers": [ + "mtusi-lab3-api-4;48.19%;70.66MiB / 512MiB", + "mtusi-lab3-api-3;50.30%;69.81MiB / 512MiB", + "mtusi-lab3-api-1;53.67%;83.95MiB / 512MiB", + "mtusi-lab3-api-2;48.05%;83.39MiB / 512MiB", + "mtusi-lab3-postgres-1;20.57%;47.53MiB / 768MiB", + "mtusi-lab3-redis-1;6.29%;3.684MiB / 256MiB", + "mtusi-lab3-traefik-1;7.31%;24.3MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.34%;3.621MiB / 7.622GiB", + "artship-frontend;13.96%;91MiB / 7.622GiB", + "artship-backend;252.40%;111.1MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "3,20,100" + }, + { + "timestamp_epoch": 1793886528.5855644, + "containers": [ + "mtusi-lab3-api-4;25.55%;70.67MiB / 512MiB", + "mtusi-lab3-api-3;27.21%;69.84MiB / 512MiB", + "mtusi-lab3-api-1;25.77%;70.93MiB / 512MiB", + "mtusi-lab3-api-2;49.37%;71.66MiB / 512MiB", + "mtusi-lab3-postgres-1;22.51%;52.78MiB / 768MiB", + "mtusi-lab3-redis-1;6.31%;3.645MiB / 256MiB", + "mtusi-lab3-traefik-1;11.01%;24.43MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.32%;3.621MiB / 7.622GiB", + "artship-frontend;16.19%;90.03MiB / 7.622GiB", + "artship-backend;223.12%;163.4MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,20,100" + }, + { + "timestamp_epoch": 1793886531.6453142, + "containers": [ + "mtusi-lab3-api-4;21.42%;70.65MiB / 512MiB", + "mtusi-lab3-api-3;24.16%;70.22MiB / 512MiB", + "mtusi-lab3-api-1;27.55%;71.43MiB / 512MiB", + "mtusi-lab3-api-2;50.69%;71.99MiB / 512MiB", + "mtusi-lab3-postgres-1;21.00%;54.07MiB / 768MiB", + "mtusi-lab3-redis-1;6.68%;3.648MiB / 256MiB", + "mtusi-lab3-traefik-1;8.88%;24.92MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.29%;3.621MiB / 7.622GiB", + "artship-frontend;9.89%;90.12MiB / 7.622GiB", + "artship-backend;0.10%;192.6MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,20,100" + }, + { + "timestamp_epoch": 1793886535.1705682, + "containers": [ + "mtusi-lab3-api-4;22.13%;70.6MiB / 512MiB", + "mtusi-lab3-api-3;24.41%;70.28MiB / 512MiB", + "mtusi-lab3-api-1;26.79%;70.86MiB / 512MiB", + "mtusi-lab3-api-2;48.76%;72.09MiB / 512MiB", + "mtusi-lab3-postgres-1;21.86%;48.79MiB / 768MiB", + "mtusi-lab3-redis-1;6.01%;3.637MiB / 256MiB", + "mtusi-lab3-traefik-1;10.19%;26.42MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.26%;3.621MiB / 7.622GiB", + "artship-frontend;12.18%;90.27MiB / 7.622GiB", + "artship-backend;0.14%;186MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,18,100" + } + ] +} diff --git a/evidence/scaling/expanded_4replicas_3cpu_3072mb.json b/evidence/scaling/expanded_4replicas_3cpu_3072mb.json new file mode 100644 index 00000000..cf1a7ec8 --- /dev/null +++ b/evidence/scaling/expanded_4replicas_3cpu_3072mb.json @@ -0,0 +1,177 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.836, + "concurrency": 8, + "successful_requests": 2936, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 95.214, + "successful_latency_ms": { + "p50": 54.992, + "p95": 238.599, + "p99": 440.463 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.", + "scenario": "expanded_4replicas_3cpu_3072mb", + "api_replicas": 4, + "total_api_cpu_budget": 3.0, + "total_api_memory_budget_mb": 3072, + "per_replica_cpu_limit": 0.75, + "per_replica_memory_limit_mb": 768, + "container_stats_samples": [ + { + "timestamp_epoch": 1793886566.411055, + "containers": [ + "mtusi-lab3-api-2;28.25%;68.31MiB / 768MiB", + "mtusi-lab3-api-3;21.60%;68.37MiB / 768MiB", + "mtusi-lab3-api-1;26.44%;68.33MiB / 768MiB", + "mtusi-lab3-api-4;27.69%;68.39MiB / 768MiB", + "mtusi-lab3-postgres-1;0.86%;26.92MiB / 768MiB", + "mtusi-lab3-redis-1;0.40%;3.516MiB / 256MiB", + "mtusi-lab3-traefik-1;1.36%;17.79MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.35%;3.625MiB / 7.622GiB", + "artship-frontend;14.11%;90.33MiB / 7.622GiB", + "artship-backend;302.03%;216.5MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,10,100" + }, + { + "timestamp_epoch": 1793886569.944521, + "containers": [ + "mtusi-lab3-api-2;33.93%;70.22MiB / 768MiB", + "mtusi-lab3-api-3;37.60%;70.11MiB / 768MiB", + "mtusi-lab3-api-1;44.63%;70.03MiB / 768MiB", + "mtusi-lab3-api-4;76.20%;70.1MiB / 768MiB", + "mtusi-lab3-postgres-1;33.73%;49.22MiB / 768MiB", + "mtusi-lab3-redis-1;8.10%;3.617MiB / 256MiB", + "mtusi-lab3-traefik-1;14.25%;20.45MiB / 256MiB", + "mtusi-lab2-postgres;6.72%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;2.97%;3.621MiB / 7.622GiB", + "artship-frontend;12.66%;90.44MiB / 7.622GiB", + "artship-backend;0.15%;208.8MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "2,19,100" + }, + { + "timestamp_epoch": 1793886573.5686126, + "containers": [ + "mtusi-lab3-api-2;57.73%;70.11MiB / 768MiB", + "mtusi-lab3-api-3;35.04%;70.22MiB / 768MiB", + "mtusi-lab3-api-1;34.08%;70.16MiB / 768MiB", + "mtusi-lab3-api-4;47.86%;70.45MiB / 768MiB", + "mtusi-lab3-postgres-1;31.37%;51.63MiB / 768MiB", + "mtusi-lab3-redis-1;7.78%;3.648MiB / 256MiB", + "mtusi-lab3-traefik-1;12.51%;24.48MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.29%;3.621MiB / 7.622GiB", + "artship-frontend;13.68%;90.56MiB / 7.622GiB", + "artship-backend;213.76%;212.7MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "3,18,100" + }, + { + "timestamp_epoch": 1793886577.2284725, + "containers": [ + "mtusi-lab3-api-2;66.81%;70.45MiB / 768MiB", + "mtusi-lab3-api-3;65.49%;70.43MiB / 768MiB", + "mtusi-lab3-api-1;64.72%;70.48MiB / 768MiB", + "mtusi-lab3-api-4;76.16%;70.75MiB / 768MiB", + "mtusi-lab3-postgres-1;51.32%;49.59MiB / 768MiB", + "mtusi-lab3-redis-1;12.75%;3.633MiB / 256MiB", + "mtusi-lab3-traefik-1;26.27%;26.46MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.29%;3.621MiB / 7.622GiB", + "artship-frontend;15.56%;90.68MiB / 7.622GiB", + "artship-backend;216.60%;104.2MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,18,100" + }, + { + "timestamp_epoch": 1793886581.7327821, + "containers": [ + "mtusi-lab3-api-2;31.71%;70.63MiB / 768MiB", + "mtusi-lab3-api-3;29.52%;70.56MiB / 768MiB", + "mtusi-lab3-api-1;32.12%;70.05MiB / 768MiB", + "mtusi-lab3-api-4;73.07%;71.19MiB / 768MiB", + "mtusi-lab3-postgres-1;27.04%;50MiB / 768MiB", + "mtusi-lab3-redis-1;7.04%;4.133MiB / 256MiB", + "mtusi-lab3-traefik-1;11.52%;26.41MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.27%;3.621MiB / 7.622GiB", + "artship-frontend;13.21%;89.98MiB / 7.622GiB", + "artship-backend;226.27%;173.4MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "2,19,100" + }, + { + "timestamp_epoch": 1793886585.4382155, + "containers": [ + "mtusi-lab3-api-2;73.60%;82.87MiB / 768MiB", + "mtusi-lab3-api-3;39.58%;75.51MiB / 768MiB", + "mtusi-lab3-api-1;41.07%;79.02MiB / 768MiB", + "mtusi-lab3-api-4;56.17%;71.06MiB / 768MiB", + "mtusi-lab3-postgres-1;32.44%;51.64MiB / 768MiB", + "mtusi-lab3-redis-1;11.38%;3.645MiB / 256MiB", + "mtusi-lab3-traefik-1;13.86%;27.03MiB / 256MiB", + "mtusi-lab2-postgres;6.78%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.32%;3.621MiB / 7.622GiB", + "artship-frontend;12.57%;90.62MiB / 7.622GiB", + "artship-backend;0.17%;203.7MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,18,100" + }, + { + "timestamp_epoch": 1793886589.0120466, + "containers": [ + "mtusi-lab3-api-2;54.66%;71.08MiB / 768MiB", + "mtusi-lab3-api-3;55.03%;70.72MiB / 768MiB", + "mtusi-lab3-api-1;53.43%;70.59MiB / 768MiB", + "mtusi-lab3-api-4;74.85%;71.19MiB / 768MiB", + "mtusi-lab3-postgres-1;50.59%;50.43MiB / 768MiB", + "mtusi-lab3-redis-1;11.39%;3.898MiB / 256MiB", + "mtusi-lab3-traefik-1;20.27%;27.12MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.32%;3.621MiB / 7.622GiB", + "artship-frontend;13.55%;90.19MiB / 7.622GiB", + "artship-backend;6.43%;183.7MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,19,100" + }, + { + "timestamp_epoch": 1793886592.0979013, + "containers": [ + "mtusi-lab3-api-2;58.72%;70.89MiB / 768MiB", + "mtusi-lab3-api-3;76.35%;70.82MiB / 768MiB", + "mtusi-lab3-api-1;51.59%;70.42MiB / 768MiB", + "mtusi-lab3-api-4;36.25%;71.21MiB / 768MiB", + "mtusi-lab3-postgres-1;31.39%;51.21MiB / 768MiB", + "mtusi-lab3-redis-1;7.97%;3.656MiB / 256MiB", + "mtusi-lab3-traefik-1;14.96%;27.13MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.29%;3.621MiB / 7.622GiB", + "artship-frontend;14.45%;91.56MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "2,20,100" + }, + { + "timestamp_epoch": 1793886596.1855414, + "containers": [ + "mtusi-lab3-api-2;72.24%;70.9MiB / 768MiB", + "mtusi-lab3-api-3;65.71%;70.86MiB / 768MiB", + "mtusi-lab3-api-1;73.48%;70.5MiB / 768MiB", + "mtusi-lab3-api-4;75.97%;71.31MiB / 768MiB", + "mtusi-lab3-postgres-1;52.91%;49.4MiB / 768MiB", + "mtusi-lab3-redis-1;13.06%;3.656MiB / 256MiB", + "mtusi-lab3-traefik-1;21.82%;27.3MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.36%;3.621MiB / 7.622GiB", + "artship-frontend;13.87%;90.72MiB / 7.622GiB", + "artship-backend;278.60%;103.4MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "2,18,100" + } + ] +} diff --git a/evidence/scaling/expanded_4replicas_4cpu_4096mb.json b/evidence/scaling/expanded_4replicas_4cpu_4096mb.json new file mode 100644 index 00000000..fb8bd145 --- /dev/null +++ b/evidence/scaling/expanded_4replicas_4cpu_4096mb.json @@ -0,0 +1,195 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.613, + "concurrency": 8, + "successful_requests": 3661, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 119.589, + "successful_latency_ms": { + "p50": 55.339, + "p95": 137.459, + "p99": 309.06 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.", + "scenario": "expanded_4replicas_4cpu_4096mb", + "api_replicas": 4, + "total_api_cpu_budget": 4.0, + "total_api_memory_budget_mb": 4096, + "per_replica_cpu_limit": 1.0, + "per_replica_memory_limit_mb": 1024, + "container_stats_samples": [ + { + "timestamp_epoch": 1793886627.59777, + "containers": [ + "mtusi-lab3-api-2;42.86%;68.36MiB / 1GiB", + "mtusi-lab3-api-1;40.90%;68.38MiB / 1GiB", + "mtusi-lab3-api-3;24.31%;69.14MiB / 1GiB", + "mtusi-lab3-api-4;14.35%;132.9MiB / 1GiB", + "mtusi-lab3-postgres-1;1.25%;26.7MiB / 768MiB", + "mtusi-lab3-redis-1;0.52%;3.531MiB / 256MiB", + "mtusi-lab3-traefik-1;17.74%;17.44MiB / 256MiB", + "mtusi-lab2-postgres;6.52%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.27%;3.621MiB / 7.622GiB", + "artship-frontend;10.52%;90.51MiB / 7.622GiB", + "artship-backend;0.11%;193.2MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,10,100" + }, + { + "timestamp_epoch": 1793886630.3140259, + "containers": [ + "mtusi-lab3-api-2;45.04%;69.82MiB / 1GiB", + "mtusi-lab3-api-1;44.53%;69.8MiB / 1GiB", + "mtusi-lab3-api-3;85.35%;70.96MiB / 1GiB", + "mtusi-lab3-api-4;40.15%;69.05MiB / 1GiB", + "mtusi-lab3-postgres-1;40.65%;48.76MiB / 768MiB", + "mtusi-lab3-redis-1;9.20%;3.637MiB / 256MiB", + "mtusi-lab3-traefik-1;18.53%;20.64MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;3.45%;3.625MiB / 7.622GiB", + "artship-frontend;13.12%;90.59MiB / 7.622GiB", + "artship-backend;157.86%;203.1MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,19,100" + }, + { + "timestamp_epoch": 1793886634.005423, + "containers": [ + "mtusi-lab3-api-2;84.35%;78.8MiB / 1GiB", + "mtusi-lab3-api-1;71.75%;70MiB / 1GiB", + "mtusi-lab3-api-3;70.38%;71.14MiB / 1GiB", + "mtusi-lab3-api-4;71.34%;70.17MiB / 1GiB", + "mtusi-lab3-postgres-1;51.92%;49.55MiB / 768MiB", + "mtusi-lab3-redis-1;17.60%;3.656MiB / 256MiB", + "mtusi-lab3-traefik-1;21.28%;25.91MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.30%;3.621MiB / 7.622GiB", + "artship-frontend;15.39%;90.41MiB / 7.622GiB", + "artship-backend;220.44%;86.46MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,19,100" + }, + { + "timestamp_epoch": 1793886637.8268003, + "containers": [ + "mtusi-lab3-api-2;68.37%;70.13MiB / 1GiB", + "mtusi-lab3-api-1;68.11%;70.14MiB / 1GiB", + "mtusi-lab3-api-3;67.25%;71.14MiB / 1GiB", + "mtusi-lab3-api-4;85.21%;70.36MiB / 1GiB", + "mtusi-lab3-postgres-1;52.19%;48.4MiB / 768MiB", + "mtusi-lab3-redis-1;13.83%;3.668MiB / 256MiB", + "mtusi-lab3-traefik-1;20.81%;25.94MiB / 256MiB", + "mtusi-lab2-postgres;6.68%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.32%;3.621MiB / 7.622GiB", + "artship-frontend;13.78%;90.77MiB / 7.622GiB", + "artship-backend;228.22%;152MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "3,18,100" + }, + { + "timestamp_epoch": 1793886640.9071434, + "containers": [ + "mtusi-lab3-api-2;87.22%;70.41MiB / 1GiB", + "mtusi-lab3-api-1;84.75%;70.23MiB / 1GiB", + "mtusi-lab3-api-3;59.53%;80.24MiB / 1GiB", + "mtusi-lab3-api-4;49.78%;70.66MiB / 1GiB", + "mtusi-lab3-postgres-1;40.80%;48.6MiB / 768MiB", + "mtusi-lab3-redis-1;10.81%;3.68MiB / 256MiB", + "mtusi-lab3-traefik-1;18.04%;26.62MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;3.08%;3.621MiB / 7.622GiB", + "artship-frontend;14.52%;90.88MiB / 7.622GiB", + "artship-backend;218.33%;195.6MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,20,100" + }, + { + "timestamp_epoch": 1793886644.6151478, + "containers": [ + "mtusi-lab3-api-2;79.01%;70.54MiB / 1GiB", + "mtusi-lab3-api-1;80.70%;70.46MiB / 1GiB", + "mtusi-lab3-api-3;72.50%;71.63MiB / 1GiB", + "mtusi-lab3-api-4;81.20%;70.66MiB / 1GiB", + "mtusi-lab3-postgres-1;64.88%;49.27MiB / 768MiB", + "mtusi-lab3-redis-1;16.34%;3.715MiB / 256MiB", + "mtusi-lab3-traefik-1;24.77%;26.93MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.34%;3.621MiB / 7.622GiB", + "artship-frontend;14.22%;90.52MiB / 7.622GiB", + "artship-backend;0.17%;188.9MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "3,18,100" + }, + { + "timestamp_epoch": 1793886648.4234097, + "containers": [ + "mtusi-lab3-api-2;50.34%;70.6MiB / 1GiB", + "mtusi-lab3-api-1;53.63%;70.6MiB / 1GiB", + "mtusi-lab3-api-3;95.66%;71.98MiB / 1GiB", + "mtusi-lab3-api-4;83.48%;70.97MiB / 1GiB", + "mtusi-lab3-postgres-1;43.67%;49.3MiB / 768MiB", + "mtusi-lab3-redis-1;10.60%;3.684MiB / 256MiB", + "mtusi-lab3-traefik-1;18.44%;26.95MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.31%;3.621MiB / 7.622GiB", + "artship-frontend;15.17%;90.36MiB / 7.622GiB", + "artship-backend;202.55%;213MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,18,100" + }, + { + "timestamp_epoch": 1793886651.5363371, + "containers": [ + "mtusi-lab3-api-2;90.84%;82.66MiB / 1GiB", + "mtusi-lab3-api-1;88.08%;82.64MiB / 1GiB", + "mtusi-lab3-api-3;57.02%;71.79MiB / 1GiB", + "mtusi-lab3-api-4;78.99%;70.83MiB / 1GiB", + "mtusi-lab3-postgres-1;44.01%;54.28MiB / 768MiB", + "mtusi-lab3-redis-1;11.09%;3.652MiB / 256MiB", + "mtusi-lab3-traefik-1;20.83%;26.93MiB / 256MiB", + "mtusi-lab2-postgres;8.55%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;3.32%;3.621MiB / 7.622GiB", + "artship-frontend;16.95%;90.47MiB / 7.622GiB", + "artship-backend;197.13%;62.77MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "2,18,100" + }, + { + "timestamp_epoch": 1793886655.3452408, + "containers": [ + "mtusi-lab3-api-2;79.65%;70.86MiB / 1GiB", + "mtusi-lab3-api-1;76.53%;70.77MiB / 1GiB", + "mtusi-lab3-api-3;77.07%;71.89MiB / 1GiB", + "mtusi-lab3-api-4;75.40%;70.84MiB / 1GiB", + "mtusi-lab3-postgres-1;65.15%;50.94MiB / 768MiB", + "mtusi-lab3-redis-1;14.22%;3.68MiB / 256MiB", + "mtusi-lab3-traefik-1;21.52%;26.4MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.29%;3.621MiB / 7.622GiB", + "artship-frontend;16.72%;90.58MiB / 7.622GiB", + "artship-backend;286.39%;91.25MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "2,18,100" + }, + { + "timestamp_epoch": 1793886659.2273002, + "containers": [ + "mtusi-lab3-api-2;0.15%;70.88MiB / 1GiB", + "mtusi-lab3-api-1;0.14%;70.85MiB / 1GiB", + "mtusi-lab3-api-3;26.51%;71.71MiB / 1GiB", + "mtusi-lab3-api-4;27.31%;84.06MiB / 1GiB", + "mtusi-lab3-postgres-1;0.11%;50.65MiB / 768MiB", + "mtusi-lab3-redis-1;0.29%;3.641MiB / 256MiB", + "mtusi-lab3-traefik-1;0.15%;25.74MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.24%;3.621MiB / 7.622GiB", + "artship-frontend;10.69%;90.65MiB / 7.622GiB", + "artship-backend;216.51%;192.8MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,18,100" + } + ] +} diff --git a/evidence/scaling/fixed_1replicas.json b/evidence/scaling/fixed_1replicas.json new file mode 100644 index 00000000..2338c2b2 --- /dev/null +++ b/evidence/scaling/fixed_1replicas.json @@ -0,0 +1,163 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 31.192, + "concurrency": 8, + "successful_requests": 1171, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 37.541, + "successful_latency_ms": { + "p50": 200.219, + "p95": 302.388, + "p99": 343.044 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.", + "scenario": "fixed_1replicas", + "api_replicas": 1, + "total_api_cpu_budget": 2.0, + "total_api_memory_budget_mb": 2048, + "per_replica_cpu_limit": 2.0, + "per_replica_memory_limit_mb": 2048, + "container_stats_samples": [ + { + "timestamp_epoch": 1793886308.9941907, + "containers": [ + "mtusi-lab3-api-2;156.65%;68.66MiB / 2GiB", + "mtusi-lab3-traefik-1;1.95%;22.2MiB / 256MiB", + "mtusi-lab3-postgres-1;3.78%;38.56MiB / 768MiB", + "mtusi-lab3-redis-1;1.14%;3.652MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;1.39%;4.688MiB / 7.622GiB", + "artship-frontend;27.42%;90.34MiB / 7.622GiB", + "artship-backend;374.29%;161MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,8,100" + }, + { + "timestamp_epoch": 1793886312.793944, + "containers": [ + "mtusi-lab3-api-2;126.05%;70.95MiB / 2GiB", + "mtusi-lab3-traefik-1;7.03%;22.25MiB / 256MiB", + "mtusi-lab3-postgres-1;16.93%;45.42MiB / 768MiB", + "mtusi-lab3-redis-1;8.24%;3.727MiB / 256MiB", + "mtusi-lab2-postgres;8.17%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.42%;3.621MiB / 7.622GiB", + "artship-frontend;16.78%;90.21MiB / 7.622GiB", + "artship-backend;283.66%;175.6MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,11,100" + }, + { + "timestamp_epoch": 1793886316.5291777, + "containers": [ + "mtusi-lab3-api-2;128.49%;71.69MiB / 2GiB", + "mtusi-lab3-traefik-1;10.37%;22.66MiB / 256MiB", + "mtusi-lab3-postgres-1;23.24%;45.76MiB / 768MiB", + "mtusi-lab3-redis-1;4.93%;3.98MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.26%;3.621MiB / 7.622GiB", + "artship-frontend;11.39%;89.81MiB / 7.622GiB", + "artship-backend;0.13%;194.1MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,11,100" + }, + { + "timestamp_epoch": 1793886320.1488795, + "containers": [ + "mtusi-lab3-api-2;127.16%;71.79MiB / 2GiB", + "mtusi-lab3-traefik-1;8.01%;24.7MiB / 256MiB", + "mtusi-lab3-postgres-1;17.77%;45.66MiB / 768MiB", + "mtusi-lab3-redis-1;4.97%;3.992MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;2.68%;3.621MiB / 7.622GiB", + "artship-frontend;10.59%;89.96MiB / 7.622GiB", + "artship-backend;1.54%;194.2MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,11,100" + }, + { + "timestamp_epoch": 1793886323.702454, + "containers": [ + "mtusi-lab3-api-2;129.85%;72.13MiB / 2GiB", + "mtusi-lab3-traefik-1;9.83%;24.86MiB / 256MiB", + "mtusi-lab3-postgres-1;17.79%;45.79MiB / 768MiB", + "mtusi-lab3-redis-1;4.94%;3.719MiB / 256MiB", + "mtusi-lab2-postgres;3.57%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.27%;3.621MiB / 7.622GiB", + "artship-frontend;13.25%;90.58MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,11,100" + }, + { + "timestamp_epoch": 1793886327.376915, + "containers": [ + "mtusi-lab3-api-2;153.00%;72.02MiB / 2GiB", + "mtusi-lab3-traefik-1;9.96%;24.62MiB / 256MiB", + "mtusi-lab3-postgres-1;25.86%;45.89MiB / 768MiB", + "mtusi-lab3-redis-1;4.45%;3.73MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.35%;3.621MiB / 7.622GiB", + "artship-frontend;15.48%;90.14MiB / 7.622GiB", + "artship-backend;378.58%;163.3MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,11,100" + }, + { + "timestamp_epoch": 1793886330.452997, + "containers": [ + "mtusi-lab3-api-2;126.84%;72.73MiB / 2GiB", + "mtusi-lab3-traefik-1;7.46%;24.89MiB / 256MiB", + "mtusi-lab3-postgres-1;15.44%;45.93MiB / 768MiB", + "mtusi-lab3-redis-1;6.95%;3.727MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.29%;3.871MiB / 7.622GiB", + "artship-frontend;14.43%;90.26MiB / 7.622GiB", + "artship-backend;312.29%;207.5MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,11,100" + }, + { + "timestamp_epoch": 1793886334.1144435, + "containers": [ + "mtusi-lab3-api-2;128.83%;72.35MiB / 2GiB", + "mtusi-lab3-traefik-1;8.33%;24.91MiB / 256MiB", + "mtusi-lab3-postgres-1;18.45%;46.34MiB / 768MiB", + "mtusi-lab3-redis-1;5.02%;3.711MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.76MiB / 7.622GiB", + "mtusi-lab2-redis;0.29%;3.621MiB / 7.622GiB", + "artship-frontend;10.77%;89.52MiB / 7.622GiB", + "artship-backend;0.36%;188MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,11,100" + }, + { + "timestamp_epoch": 1793886337.7399256, + "containers": [ + "mtusi-lab3-api-2;146.45%;82.47MiB / 2GiB", + "mtusi-lab3-traefik-1;8.20%;25.16MiB / 256MiB", + "mtusi-lab3-postgres-1;27.85%;46.15MiB / 768MiB", + "mtusi-lab3-redis-1;4.50%;3.734MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.29%;3.621MiB / 7.622GiB", + "artship-frontend;13.33%;90.15MiB / 7.622GiB", + "artship-backend;31.27%;190.1MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,11,100" + }, + { + "timestamp_epoch": 1793886341.2850015, + "containers": [ + "mtusi-lab3-api-2;97.10%;72.21MiB / 2GiB", + "mtusi-lab3-traefik-1;0.15%;24.65MiB / 256MiB", + "mtusi-lab3-postgres-1;0.12%;42.68MiB / 768MiB", + "mtusi-lab3-redis-1;0.26%;3.715MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.27%;3.621MiB / 7.622GiB", + "artship-frontend;10.22%;90.5MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,9,100" + } + ] +} diff --git a/evidence/scaling/fixed_2replicas.json b/evidence/scaling/fixed_2replicas.json new file mode 100644 index 00000000..6c5a4f48 --- /dev/null +++ b/evidence/scaling/fixed_2replicas.json @@ -0,0 +1,175 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 31.092, + "concurrency": 8, + "successful_requests": 1841, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 59.211, + "successful_latency_ms": { + "p50": 115.483, + "p95": 294.656, + "p99": 422.202 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.", + "scenario": "fixed_2replicas", + "api_replicas": 2, + "total_api_cpu_budget": 2.0, + "total_api_memory_budget_mb": 2048, + "per_replica_cpu_limit": 1.0, + "per_replica_memory_limit_mb": 1024, + "container_stats_samples": [ + { + "timestamp_epoch": 1793886376.9756248, + "containers": [ + "mtusi-lab3-api-1;51.87%;68.37MiB / 1GiB", + "mtusi-lab3-api-2;77.98%;132.9MiB / 1GiB", + "mtusi-lab3-redis-1;0.55%;3.531MiB / 256MiB", + "mtusi-lab3-postgres-1;1.24%;23.3MiB / 768MiB", + "mtusi-lab3-traefik-1;4.24%;18.92MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.34%;3.621MiB / 7.622GiB", + "artship-frontend;20.40%;90.15MiB / 7.622GiB", + "artship-backend;104.68%;216.8MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,8,100" + }, + { + "timestamp_epoch": 1793886380.6233075, + "containers": [ + "mtusi-lab3-api-1;63.34%;69.52MiB / 1GiB", + "mtusi-lab3-api-2;99.86%;70.32MiB / 1GiB", + "mtusi-lab3-redis-1;6.89%;3.621MiB / 256MiB", + "mtusi-lab3-postgres-1;25.24%;37.15MiB / 768MiB", + "mtusi-lab3-traefik-1;12.69%;17.4MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;1.74%;5.023MiB / 7.622GiB", + "artship-frontend;16.37%;90MiB / 7.622GiB", + "artship-backend;0.13%;186.8MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,14,100" + }, + { + "timestamp_epoch": 1793886384.450458, + "containers": [ + "mtusi-lab3-api-1;102.42%;71.07MiB / 1GiB", + "mtusi-lab3-api-2;62.14%;79.63MiB / 1GiB", + "mtusi-lab3-redis-1;6.78%;3.641MiB / 256MiB", + "mtusi-lab3-postgres-1;23.87%;37.39MiB / 768MiB", + "mtusi-lab3-traefik-1;12.01%;22.12MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.21%;3.621MiB / 7.622GiB", + "artship-frontend;12.24%;91.39MiB / 7.622GiB", + "artship-backend;55.03%;216MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,12,100" + }, + { + "timestamp_epoch": 1793886388.0942245, + "containers": [ + "mtusi-lab3-api-1;76.11%;70.86MiB / 1GiB", + "mtusi-lab3-api-2;102.72%;70.89MiB / 1GiB", + "mtusi-lab3-redis-1;10.08%;3.652MiB / 256MiB", + "mtusi-lab3-postgres-1;40.86%;37.18MiB / 768MiB", + "mtusi-lab3-traefik-1;19.01%;23.29MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.40%;3.621MiB / 7.622GiB", + "artship-frontend;27.12%;90.24MiB / 7.622GiB", + "artship-backend;248.73%;86.68MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "2,14,100" + }, + { + "timestamp_epoch": 1793886391.515072, + "containers": [ + "mtusi-lab3-api-1;59.60%;71MiB / 1GiB", + "mtusi-lab3-api-2;99.22%;71.54MiB / 1GiB", + "mtusi-lab3-redis-1;6.07%;3.645MiB / 256MiB", + "mtusi-lab3-postgres-1;21.92%;37.7MiB / 768MiB", + "mtusi-lab3-traefik-1;10.00%;23.32MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;3.11%;3.621MiB / 7.622GiB", + "artship-frontend;19.89%;90.33MiB / 7.622GiB", + "artship-backend;278.19%;162.1MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,14,100" + }, + { + "timestamp_epoch": 1793886395.2497733, + "containers": [ + "mtusi-lab3-api-1;98.55%;71.2MiB / 1GiB", + "mtusi-lab3-api-2;71.64%;71.15MiB / 1GiB", + "mtusi-lab3-redis-1;6.33%;3.645MiB / 256MiB", + "mtusi-lab3-postgres-1;24.14%;38.01MiB / 768MiB", + "mtusi-lab3-traefik-1;11.56%;24.08MiB / 256MiB", + "mtusi-lab2-postgres;4.45%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.24%;3.621MiB / 7.622GiB", + "artship-frontend;14.77%;89.61MiB / 7.622GiB", + "artship-backend;0.11%;206MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "2,14,100" + }, + { + "timestamp_epoch": 1793886398.833462, + "containers": [ + "mtusi-lab3-api-1;62.39%;71.52MiB / 1GiB", + "mtusi-lab3-api-2;98.78%;71.27MiB / 1GiB", + "mtusi-lab3-redis-1;7.11%;3.652MiB / 256MiB", + "mtusi-lab3-postgres-1;33.22%;39.12MiB / 768MiB", + "mtusi-lab3-traefik-1;12.71%;24.46MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.22%;3.621MiB / 7.622GiB", + "artship-frontend;12.62%;90.27MiB / 7.622GiB", + "artship-backend;0.12%;190.3MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,14,100" + }, + { + "timestamp_epoch": 1793886401.9088044, + "containers": [ + "mtusi-lab3-api-1;100.93%;71.64MiB / 1GiB", + "mtusi-lab3-api-2;70.64%;71.34MiB / 1GiB", + "mtusi-lab3-redis-1;6.92%;3.652MiB / 256MiB", + "mtusi-lab3-postgres-1;25.53%;38.7MiB / 768MiB", + "mtusi-lab3-traefik-1;10.80%;24.73MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.28%;3.621MiB / 7.622GiB", + "artship-frontend;14.29%;89.85MiB / 7.622GiB", + "artship-backend;163.06%;231.5MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,13,100" + }, + { + "timestamp_epoch": 1793886405.4339893, + "containers": [ + "mtusi-lab3-api-1;73.26%;71.46MiB / 1GiB", + "mtusi-lab3-api-2;100.07%;71.77MiB / 1GiB", + "mtusi-lab3-redis-1;7.43%;3.645MiB / 256MiB", + "mtusi-lab3-postgres-1;27.75%;39.54MiB / 768MiB", + "mtusi-lab3-traefik-1;11.30%;24.62MiB / 256MiB", + "mtusi-lab2-postgres;7.36%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.33%;3.621MiB / 7.622GiB", + "artship-frontend;15.82%;90.02MiB / 7.622GiB", + "artship-backend;257.77%;116.1MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "3,13,100" + }, + { + "timestamp_epoch": 1793886409.1543102, + "containers": [ + "mtusi-lab3-api-1;23.24%;71.61MiB / 1GiB", + "mtusi-lab3-api-2;61.54%;71.61MiB / 1GiB", + "mtusi-lab3-redis-1;3.04%;3.609MiB / 256MiB", + "mtusi-lab3-postgres-1;19.24%;35.26MiB / 768MiB", + "mtusi-lab3-traefik-1;5.64%;24.61MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.31%;3.621MiB / 7.622GiB", + "artship-frontend;14.31%;91.09MiB / 7.622GiB", + "artship-backend;307.13%;179.4MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,12,100" + } + ] +} diff --git a/evidence/scaling/fixed_4replicas.json b/evidence/scaling/fixed_4replicas.json new file mode 100644 index 00000000..c42773b2 --- /dev/null +++ b/evidence/scaling/fixed_4replicas.json @@ -0,0 +1,195 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.982, + "concurrency": 8, + "successful_requests": 2041, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 65.877, + "successful_latency_ms": { + "p50": 49.308, + "p95": 390.895, + "p99": 564.725 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.", + "scenario": "fixed_4replicas", + "api_replicas": 4, + "total_api_cpu_budget": 2.0, + "total_api_memory_budget_mb": 2048, + "per_replica_cpu_limit": 0.5, + "per_replica_memory_limit_mb": 512, + "container_stats_samples": [ + { + "timestamp_epoch": 1793886439.8320873, + "containers": [ + "mtusi-lab3-api-1;14.55%;76.53MiB / 512MiB", + "mtusi-lab3-api-4;22.31%;67.68MiB / 512MiB", + "mtusi-lab3-api-2;30.78%;77.67MiB / 512MiB", + "mtusi-lab3-api-3;23.98%;129.4MiB / 512MiB", + "mtusi-lab3-postgres-1;8.71%;29.34MiB / 768MiB", + "mtusi-lab3-redis-1;2.42%;3.527MiB / 256MiB", + "mtusi-lab3-traefik-1;5.67%;17.83MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.23%;3.621MiB / 7.622GiB", + "artship-frontend;6.88%;91.35MiB / 7.622GiB", + "artship-backend;33.55%;225.6MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,11,100" + }, + { + "timestamp_epoch": 1793886443.32589, + "containers": [ + "mtusi-lab3-api-1;40.97%;68.92MiB / 512MiB", + "mtusi-lab3-api-4;38.69%;69.05MiB / 512MiB", + "mtusi-lab3-api-2;41.56%;68.95MiB / 512MiB", + "mtusi-lab3-api-3;0.52%;68.41MiB / 512MiB", + "mtusi-lab3-postgres-1;0.99%;29.95MiB / 768MiB", + "mtusi-lab3-redis-1;7.58%;3.621MiB / 256MiB", + "mtusi-lab3-traefik-1;12.74%;17.97MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.33%;3.621MiB / 7.622GiB", + "artship-frontend;13.31%;90.68MiB / 7.622GiB", + "artship-backend;284.48%;125.1MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,17,100" + }, + { + "timestamp_epoch": 1793886446.9308507, + "containers": [ + "mtusi-lab3-api-1;35.63%;70.45MiB / 512MiB", + "mtusi-lab3-api-4;22.38%;69.54MiB / 512MiB", + "mtusi-lab3-api-2;41.30%;69.42MiB / 512MiB", + "mtusi-lab3-api-3;52.35%;70.25MiB / 512MiB", + "mtusi-lab3-postgres-1;23.56%;49.49MiB / 768MiB", + "mtusi-lab3-redis-1;5.55%;3.891MiB / 256MiB", + "mtusi-lab3-traefik-1;9.18%;19.32MiB / 256MiB", + "mtusi-lab2-postgres;7.12%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.35%;3.621MiB / 7.622GiB", + "artship-frontend;12.13%;90.22MiB / 7.622GiB", + "artship-backend;169.33%;197.8MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,19,100" + }, + { + "timestamp_epoch": 1793886450.341239, + "containers": [ + "mtusi-lab3-api-1;32.69%;70.29MiB / 512MiB", + "mtusi-lab3-api-4;31.28%;69.4MiB / 512MiB", + "mtusi-lab3-api-2;31.14%;69.56MiB / 512MiB", + "mtusi-lab3-api-3;48.61%;70.59MiB / 512MiB", + "mtusi-lab3-postgres-1;32.50%;49.94MiB / 768MiB", + "mtusi-lab3-redis-1;9.24%;3.637MiB / 256MiB", + "mtusi-lab3-traefik-1;13.54%;23.32MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.25%;3.621MiB / 7.622GiB", + "artship-frontend;11.36%;90.63MiB / 7.622GiB", + "artship-backend;0.12%;193.9MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,18,100" + }, + { + "timestamp_epoch": 1793886453.8616302, + "containers": [ + "mtusi-lab3-api-1;20.90%;70.34MiB / 512MiB", + "mtusi-lab3-api-4;29.44%;70.47MiB / 512MiB", + "mtusi-lab3-api-2;30.87%;69.68MiB / 512MiB", + "mtusi-lab3-api-3;48.38%;70.76MiB / 512MiB", + "mtusi-lab3-postgres-1;26.14%;52.14MiB / 768MiB", + "mtusi-lab3-redis-1;6.99%;3.609MiB / 256MiB", + "mtusi-lab3-traefik-1;12.03%;24.61MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.30%;3.621MiB / 7.622GiB", + "artship-frontend;13.37%;90.25MiB / 7.622GiB", + "artship-backend;212.77%;217.8MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,20,100" + }, + { + "timestamp_epoch": 1793886457.4135027, + "containers": [ + "mtusi-lab3-api-1;40.25%;79.11MiB / 512MiB", + "mtusi-lab3-api-4;36.32%;73.41MiB / 512MiB", + "mtusi-lab3-api-2;34.07%;69.7MiB / 512MiB", + "mtusi-lab3-api-3;48.66%;70.86MiB / 512MiB", + "mtusi-lab3-postgres-1;26.59%;50.24MiB / 768MiB", + "mtusi-lab3-redis-1;7.12%;3.637MiB / 256MiB", + "mtusi-lab3-traefik-1;13.18%;25.34MiB / 256MiB", + "mtusi-lab2-postgres;7.89%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.35%;3.621MiB / 7.622GiB", + "artship-frontend;15.27%;90.54MiB / 7.622GiB", + "artship-backend;233.64%;83.11MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,19,100" + }, + { + "timestamp_epoch": 1793886460.5889723, + "containers": [ + "mtusi-lab3-api-1;30.46%;70.4MiB / 512MiB", + "mtusi-lab3-api-4;29.90%;70.57MiB / 512MiB", + "mtusi-lab3-api-2;28.90%;69.97MiB / 512MiB", + "mtusi-lab3-api-3;48.58%;70.95MiB / 512MiB", + "mtusi-lab3-postgres-1;31.68%;53.58MiB / 768MiB", + "mtusi-lab3-redis-1;6.92%;3.629MiB / 256MiB", + "mtusi-lab3-traefik-1;11.86%;24.99MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.31%;3.621MiB / 7.622GiB", + "artship-frontend;12.86%;90.39MiB / 7.622GiB", + "artship-backend;229.79%;151.4MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,20,100" + }, + { + "timestamp_epoch": 1793886464.2206683, + "containers": [ + "mtusi-lab3-api-1;48.31%;70.61MiB / 512MiB", + "mtusi-lab3-api-4;45.63%;70.41MiB / 512MiB", + "mtusi-lab3-api-2;30.25%;70.02MiB / 512MiB", + "mtusi-lab3-api-3;22.41%;71.05MiB / 512MiB", + "mtusi-lab3-postgres-1;18.41%;53.68MiB / 768MiB", + "mtusi-lab3-redis-1;4.46%;3.617MiB / 256MiB", + "mtusi-lab3-traefik-1;8.34%;25.7MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.20%;3.621MiB / 7.622GiB", + "artship-frontend;10.76%;90.5MiB / 7.622GiB", + "artship-backend;0.12%;195.6MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,19,100" + }, + { + "timestamp_epoch": 1793886467.790955, + "containers": [ + "mtusi-lab3-api-1;32.46%;70.68MiB / 512MiB", + "mtusi-lab3-api-4;32.38%;70.47MiB / 512MiB", + "mtusi-lab3-api-2;31.19%;70.07MiB / 512MiB", + "mtusi-lab3-api-3;51.48%;71.19MiB / 512MiB", + "mtusi-lab3-postgres-1;27.38%;52.98MiB / 768MiB", + "mtusi-lab3-redis-1;7.26%;3.891MiB / 256MiB", + "mtusi-lab3-traefik-1;14.21%;25.74MiB / 256MiB", + "mtusi-lab2-postgres;4.97%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;2.31%;3.656MiB / 7.622GiB", + "artship-frontend;9.96%;90.6MiB / 7.622GiB", + "artship-backend;3.71%;183.3MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,20,100" + }, + { + "timestamp_epoch": 1793886470.821725, + "containers": [ + "mtusi-lab3-api-1;45.51%;80.78MiB / 512MiB", + "mtusi-lab3-api-4;44.33%;80.57MiB / 512MiB", + "mtusi-lab3-api-2;21.53%;70.02MiB / 512MiB", + "mtusi-lab3-api-3;30.89%;80.72MiB / 512MiB", + "mtusi-lab3-postgres-1;25.84%;51.66MiB / 768MiB", + "mtusi-lab3-redis-1;5.05%;3.633MiB / 256MiB", + "mtusi-lab3-traefik-1;10.13%;26.51MiB / 256MiB", + "mtusi-lab2-postgres;0.00%;20.72MiB / 7.622GiB", + "mtusi-lab2-redis;0.24%;3.621MiB / 7.622GiB", + "artship-frontend;12.54%;89.95MiB / 7.622GiB", + "artship-backend;292.64%;140.2MiB / 7.622GiB" + ], + "postgres_active_total_max_connections": "1,18,100" + } + ] +} diff --git a/evidence/scaling/p95-latency.png b/evidence/scaling/p95-latency.png new file mode 100644 index 0000000000000000000000000000000000000000..bbf793d9de164f4eac2099d46bb08228787a3c0f GIT binary patch literal 51806 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 a#e3%oz3WLUjm~P)io3gdxsQ=1sr z83+WzrZcDiR3Q-7_Yep_?fPXs{7FODb3gcpw8IHa2UY7U4$hbCj0xv1IoMcOJ6M<+ z?s77=vp2Q2Iw&lXJSQk$NmUSXTM zhTd>Tjdn|kQ(BU-&_%WrTSpA(eOMTG?Kxpeksn-%dh50R%KE1LyAMX!PklOL_ci~` zn{#7lA6S2|ueQtA6^2KEAMfi|mBYg6sQ>b_4fUVO7x{arzr}ce|Fa|O4pIM%cNZNe z^*82wgw5377)}#5P=BNU!~3VT-@MoTRz|(<5xQS{sDJr?+U3eb#LSvr@Cpblo{Jxh z_VRqv^)Z9IgnKnLXlWZ!nE}`rVkQxa4+>vcA zX4>$4$?<`HyiY^E{osg1z1-r6=Dmg4(eSQ%RvnAo5PJV_huH*j_gLGl76ZymTy5+R>NWYbm|j zQKWcUWhAdJpuK-MwN!3p{Fc00yD)KbOZs$!;;Ff@u1vj&SKH3F@u=C&bvc`S)M3c8 zDw?PqY14L}sK|8m6UqrIrY8^tvv4}c8DsayxK0gBZERuHb9iq?Zg!sQ_VQva>c17D zSpF+RPgo<_x->E}HM>RI_Vw;tZAS@&BX73gY-U@f7SCq1K8jCJjlVLeD46~?UN$&* zeZ?5OSQ8tJn!CDesM52O{=Rp%?W=rb61BrTCI5;9S$0v`OW)0i&O_Hxt3dbIA za(i^M)4U_gG%4*RL;C8cv+Z~{gvRSI}TpCeB8$>zyD#oO_-lx#_24x zX8r=FQFfWHMfSRm%|ubF&O8P3bF<>5Da{};HchjjS^INbUP}}6%U`{?YeY)jXP4sA zO#Q`MUe6ADtuA(liJPm3kYg_?i{yWLFfvQdG7XYV9qq`j892L0?p|T#_L#nqJx6KL zv97puYbUEfYLT6KY-`jTzE0mdLBZvb@xwRzjFiRbZX=#E9+bxD zmEbOeYl1^Lvz_+!+vVKn4@bu@m7J;SoF!XFTZS(LErcx0EzfmpxN%HPxvS^adk(`g z_ilK;4kC!}u3GbulE0I;OTRUR6;gk!K+2y}>VVAhV)tr5DU6`)mxTD1Lrs1EY~bb$ z+IK!B>#&d2Q1EsCId~B^4@&s4a(GpdLicLE_*Xt``r9k+m3XiA`iW%NWW;&LNSj7K zA0Nza)lbYi?D1=~66`43!?SHh>78~p#s=eT+695kMYTJwpADA~@|^#8%Vl+WE_0Aa zw$=V7$B^F&1OXXF4FQEGmeR!wUlJ$a1#4L(Vs|AOlzM8}gbHf}U(a+X7>WzeXsz8W zGqPVJdUa_~zDm4RSJkwAdZ;ne4QTV9sRIQ}R$EoZ0uJ$*h+Pr?-P} zp_2e1-FwezgQ9qbIDwSBJ&e0luHG-vRSNmjHDM1QG4#3jUZ2Ye=NP0KW|*%&7wI`K zGn(Zx`DR~YQQ$PsO3C6_xX54%~e02fk{`KJFOtNB( z-6|E8#-V!ZS>wrDgbO}Dog5#1@hrf%)xb-(GGHf1UsYiJ>|Ap0hsVT!Vo6VrDLx@q zFvKv&#cufm0kJM>uqm{ubecV^@!gZ-nO`ECgo*cK2m895yK5IBk2R}3dC32_3b8*z zMKhfA zor-7f6x^sHui`bSB5qva8K+9J30Lhf7_vUn(S2Ti*&%1O(LQvA>-qA%*`bfOxb^!y zy6tL&wB{dL?IV`QDb!}ktENRiUk>N*Yp@TtI%vT1s3Uf;$GLP-uSK})B*|TOi%M8g zqmqpAM;+3&vmZ4Wa#XqXuMNeHI7X~g#@0+dIF_sC`e@zUbgsb8#37e6e;Je5&mA2& zx?!i9k+{{h;`njP;pE&p;la7~q4;Pne|GU|lDw*yYAM^z)?Wz(9%0Dk%x~@MWkaid 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

A8Oe!s{HuAK#mKVAYxS(nF&mpPk~}iz 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 literal 0 HcmV?d00001 diff --git a/evidence/smoke-final.txt b/evidence/smoke-final.txt new file mode 100644 index 00000000..fc20f9dd --- /dev/null +++ b/evidence/smoke-final.txt @@ -0,0 +1 @@ +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. diff --git a/migrations/README b/migrations/README new file mode 100644 index 00000000..98e4f9c4 --- /dev/null +++ b/migrations/README @@ -0,0 +1 @@ +Generic single-database configuration. \ No newline at end of file diff --git a/migrations/env.py b/migrations/env.py new file mode 100644 index 00000000..0bc520ad --- /dev/null +++ b/migrations/env.py @@ -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() \ No newline at end of file diff --git a/migrations/script.py.mako b/migrations/script.py.mako new file mode 100644 index 00000000..fbc4b07d --- /dev/null +++ b/migrations/script.py.mako @@ -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"} diff --git a/migrations/versions/21ad89656327_create_initial_database_schema.py b/migrations/versions/21ad89656327_create_initial_database_schema.py new file mode 100644 index 00000000..6c48b769 --- /dev/null +++ b/migrations/versions/21ad89656327_create_initial_database_schema.py @@ -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 ### diff --git a/migrations/versions/8c3d9f4a21b7_add_idempotency_records.py b/migrations/versions/8c3d9f4a21b7_add_idempotency_records.py new file mode 100644 index 00000000..a228b426 --- /dev/null +++ b/migrations/versions/8c3d9f4a21b7_add_idempotency_records.py @@ -0,0 +1,39 @@ +"""add shared PostgreSQL idempotency records + +Revision ID: 8c3d9f4a21b7 +Revises: 21ad89656327 +Create Date: 2026-11-05 +""" +from typing import Sequence, Union +from alembic import op +import sqlalchemy as sa + +revision: str = "8c3d9f4a21b7" +down_revision: Union[str, None] = "21ad89656327" +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + op.create_table( + "idempotency_records", + sa.Column("id", sa.UUID(), nullable=False), + sa.Column("user_id", sa.UUID(), nullable=False), + sa.Column("method", sa.String(length=10), nullable=False), + sa.Column("path", sa.String(length=255), nullable=False), + sa.Column("idempotency_key", sa.String(length=128), nullable=False), + sa.Column("request_hash", sa.String(length=64), nullable=False), + sa.Column("message_id", sa.UUID(), nullable=True), + sa.Column("created_at", sa.DateTime(timezone=True), nullable=False), + sa.Column("expires_at", sa.DateTime(timezone=True), nullable=False), + sa.ForeignKeyConstraint(["message_id"], ["messages.id"], ondelete="CASCADE"), + sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="CASCADE"), + sa.PrimaryKeyConstraint("id"), + sa.UniqueConstraint("user_id", "method", "path", "idempotency_key", name="uq_idempotency_scope_key"), + ) + op.create_index("ix_idempotency_records_expires_at", "idempotency_records", ["expires_at"], unique=False) + + +def downgrade() -> None: + op.drop_index("ix_idempotency_records_expires_at", table_name="idempotency_records") + op.drop_table("idempotency_records") diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..e519117f --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/scripts/analyze-scaling.py b/scripts/analyze-scaling.py new file mode 100644 index 00000000..de77ecdf --- /dev/null +++ b/scripts/analyze-scaling.py @@ -0,0 +1,52 @@ + +#!/usr/bin/env python3 +"""Create charts from real Track 1 summary.csv data; does not invent measurements.""" + +import csv +from pathlib import Path +import matplotlib.pyplot as plt + +root = Path(__file__).resolve().parents[1] +source = root / 'evidence' / 'scaling' / 'summary.csv' + +if not source.exists(): + raise SystemExit('Run scripts/run-scaling-experiment.py first') + +with source.open(encoding='utf-8', newline='') as f: + rows = list(csv.DictReader(f)) + +if not rows: + raise SystemExit('summary.csv is empty') + +out = source.parent + +for key, title, ylabel, filename in [ + ('successful_rps', 'Track 1: successful throughput', + 'Successful requests/sec', 'throughput.png'), + ('p95_ms', 'Track 1: p95 latency', + 'Milliseconds', 'p95-latency.png'), + ('error_ratio', 'Track 1: error ratio', + 'Error ratio', 'errors.png'), +]: + labels = [r['scenario'] for r in rows] + values = [float(r[key]) if r[key] else 0 for r in rows] + + plt.figure(figsize=(11, 5)) + plt.bar(labels, values) + + if key == 'error_ratio': + plt.ylim(0, 0.01) + for i, value in enumerate(values): + plt.text( + i, 0.0002, f'{value:.1%}', + ha='center', va='bottom' + ) + + plt.title(title) + plt.ylabel(ylabel) + plt.xticks(rotation=25, ha='right') + plt.tight_layout() + plt.savefig(out / filename, dpi=160) + plt.close() + +print('Charts written to', out) diff --git a/scripts/concurrent-idempotency.py b/scripts/concurrent-idempotency.py new file mode 100644 index 00000000..0253e5a3 --- /dev/null +++ b/scripts/concurrent-idempotency.py @@ -0,0 +1,40 @@ +#!/usr/bin/env python3 +"""Concurrent idempotency verification through the public load-balancer URL.""" +from concurrent.futures import ThreadPoolExecutor +import uuid +import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests")) +from client import Client, Failure, arguments, check, run + + +def main(): + def configure(p): + p.add_argument('--requests', type=int, default=20) + args = arguments('Concurrent cross-replica idempotency test', configure) + check(2 <= args.requests <= 100, 'requests must be 2..100') + c = Client(args.base_url, args.ca_file, timeout=10) + alice, bob, eve, chat = c.bootstrap() + key = 'race-' + uuid.uuid4().hex + body = 'same concurrent request ' + uuid.uuid4().hex + + def send(_): + return Client(args.base_url, args.ca_file, timeout=10).message(alice, chat, body, key=key) + + with ThreadPoolExecutor(max_workers=args.requests) as pool: + responses = list(pool.map(send, range(args.requests))) + messages = [r['json'] for r in responses] + check(all(m == messages[0] for m in messages), 'concurrent retries returned different messages') + instances = {r['headers'].get('X-Instance-Id') for r in responses} + check(None not in instances, 'missing X-Instance-Id') + check(len(instances) >= 2, 'load balancer did not expose at least two API replicas') + check(len({m['id'] for m in messages}) == 1, 'concurrent retries created duplicates') + conflict = c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 409, + actor=alice, body={'text': body + ' changed'}, + headers={'Idempotency-Key': key}) + print({'requests': args.requests, 'unique_message_ids': 1, + 'observed_instances': len(instances), 'different_body_status': conflict['status']}) + print('PASS: concurrent same-key requests produced exactly one message') + +if __name__ == '__main__': + run(main) diff --git a/scripts/load-diagnostic.py b/scripts/load-diagnostic.py new file mode 100644 index 00000000..a958e494 --- /dev/null +++ b/scripts/load-diagnostic.py @@ -0,0 +1,116 @@ +#!/usr/bin/env python3 +"""Diagnostic closed-loop load test. Does not modify public tests.""" +from concurrent.futures import ThreadPoolExecutor +from collections import Counter +from pathlib import Path +import json +import math +import re +import sys +import threading +import time + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) + +from client import Client, Failure, LAB, arguments, check, run + + +def main(): + def configure(p): + p.add_argument('--duration', type=float, default=90) + p.add_argument('--concurrency', type=int, default=8) + p.add_argument('--output', default='evidence/rolling-update-diagnostic.json') + + args = arguments('Diagnostic synthetic POST message load', configure) + check(1 <= args.duration <= 3600, 'duration must be 1..3600 seconds') + check(1 <= args.concurrency <= 128, 'concurrency must be 1..128') + + c = Client(args.base_url, args.ca_file) + alice, bob, eve, chat = c.bootstrap() + barrier = threading.Barrier(args.concurrency) + + def worker(worker_id): + local = Client(args.base_url, args.ca_file, timeout=5) + barrier.wait() + deadline = time.monotonic() + args.duration + latencies = [] + errors = Counter() + examples = [] + index = 0 + + while time.monotonic() < deadline: + start = time.monotonic() + try: + local.message(alice, chat, 'diagnostic-%s-%s' % (worker_id, index)) + latencies.append(time.monotonic() - start) + except Failure as exc: + message = str(exc) + match = re.search(r'received (\d{3})', message) + + if match: + category = 'http_' + match.group(1) + elif 'connection/TLS failure' in message: + kind = re.search(r'\(([^)]+)\)', message) + category = 'connection_' + (kind.group(1) if kind else 'unknown') + else: + category = 'other_failure' + + errors[category] += 1 + if len(examples) < 10: + examples.append(message[:300]) + + index += 1 + + return latencies, errors, examples + + started = time.monotonic() + with ThreadPoolExecutor(max_workers=args.concurrency) as pool: + results = list(pool.map(worker, range(args.concurrency))) + elapsed = time.monotonic() - started + + latencies = sorted(x for values, _, _ in results for x in values) + errors = Counter() + examples = [] + + for _, counts, samples in results: + errors.update(counts) + examples.extend(samples) + + total_errors = sum(errors.values()) + total = len(latencies) + total_errors + + def percentile(p): + if not latencies: + return None + return round(1000 * latencies[max(0, math.ceil(p * len(latencies)) - 1)], 3) + + report = { + 'lab': LAB, + 'workload': 'closed-loop POST messages; no automatic retries', + 'duration_seconds': round(elapsed, 3), + 'concurrency': args.concurrency, + 'successful_requests': len(latencies), + 'failed_requests': total_errors, + 'error_ratio': round(total_errors / total, 6) if total else None, + 'errors_by_type': dict(errors), + 'successful_rps': round(len(latencies) / elapsed, 3), + 'successful_latency_ms': { + 'p50': percentile(.50), + 'p95': percentile(.95), + 'p99': percentile(.99) + }, + 'error_examples': examples[:20], + 'note': 'Latency percentiles cover successful requests only.' + } + + text = json.dumps(report, ensure_ascii=False, indent=2) + dest = Path(args.output) + dest.parent.mkdir(parents=True, exist_ok=True) + dest.write_text(text + '\n', encoding='utf-8') + print(text) + check(bool(latencies), 'no successful writes') + + +if __name__ == '__main__': + run(main) diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..cd4695e5 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +# Restart all stateful dependencies and all API replicas without touching volumes. +docker compose restart postgres redis api diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100644 index 00000000..4cbb334a --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,46 @@ +#!/usr/bin/env bash +set -eu +# Compose does not provide a native rolling-update primitive. This script +# performs a surge replacement: add one new healthy replica, then remove one old. +desired="${API_REPLICAS:-2}" +load_duration="${ROLLING_LOAD_DURATION:-90}" +load_script="${LOAD_SCRIPT:-tests/load.py}" +load_output="${ROLLING_LOAD_OUTPUT:-evidence/rolling-update-load.json}" +load_log="${ROLLING_LOAD_LOG:-evidence/rolling-update-load.log}" +if [ "$desired" -lt 2 ]; then echo 'API_REPLICAS must be >= 2' >&2; exit 2; fi + +docker compose build api +python "$load_script" --base-url http://localhost:8080 --duration "$load_duration" --concurrency 8 --output "$load_output" >"$load_log" 2>&1 & +load_pid=$! +cleanup() { kill "$load_pid" 2>/dev/null || true; wait "$load_pid" 2>/dev/null || true; } +trap cleanup EXIT INT TERM + +# Capture the old replica ids. Each iteration adds a new container before removing an old one. +old_ids=$(docker compose ps -q api) +for old_id in $old_ids; do + before=$(docker compose ps -q api | sort) + docker compose up -d --no-deps --no-recreate --scale "api=$((desired + 1))" api + new_id='' + attempt=0 + while [ "$attempt" -lt 60 ]; do + after=$(docker compose ps -q api | sort) + new_id=$(comm -13 <(printf '%s\n' "$before") <(printf '%s\n' "$after") | head -n 1 || true) + if [ -n "$new_id" ]; then + health=$(docker inspect --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}' "$new_id") + if [ "$health" = healthy ]; then break; fi + fi + attempt=$((attempt + 1)); sleep 2 + done + if [ -z "$new_id" ] || [ "${health:-}" != healthy ]; then + echo 'New replica did not become healthy; leaving old replicas running' >&2 + exit 1 + fi + docker exec "$old_id" sh -c 'touch /tmp/api-draining' + sleep 10 + docker stop --timeout 20 "$old_id" >/dev/null + docker rm "$old_id" >/dev/null + docker compose up -d --no-deps --no-recreate --scale "api=$desired" api + python scripts/wait-ready.py http://localhost:8080/health/ready 30 +done +wait "$load_pid" || { echo 'Load test failed; inspect evidence/rolling-update-load.log' >&2; exit 1; } +trap - EXIT INT TERM diff --git a/scripts/run-scaling-experiment.py b/scripts/run-scaling-experiment.py new file mode 100644 index 00000000..24e00595 --- /dev/null +++ b/scripts/run-scaling-experiment.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +"""Run Track 1 scenarios on the user's Docker host; records only measured results.""" +import argparse +import csv +import json +from pathlib import Path +import subprocess +import sys +import time + +ROOT = Path(__file__).resolve().parents[1] +OUT = ROOT / 'evidence' / 'scaling' +BASE_ENV = ROOT / '.env' + + +def run(cmd, env=None, check=True, capture=False): + return subprocess.run(cmd, cwd=ROOT, env=env, check=check, + text=True, stdout=subprocess.PIPE if capture else None, + stderr=subprocess.STDOUT if capture else None) + + +def stats(): + p = run(['docker', 'stats', '--no-stream', '--format', '{{.Name}};{{.CPUPerc}};{{.MemUsage}}'], capture=True) + return p.stdout.strip().splitlines() + + +def env_value(source, key, default): + prefix = key + '=' + for line in source.splitlines(): + if line.startswith(prefix): + return line[len(prefix):].strip().strip('\"').strip("'") + return default + + +def db_activity(env_path, db_user, db_name): + query = "SELECT count(*) FILTER (WHERE state='active'), count(*), current_setting('max_connections') FROM pg_stat_activity" + result = run(['docker', 'compose', '--env-file', str(env_path), 'exec', '-T', 'postgres', + 'psql', '-U', db_user, '-d', db_name, '-At', '-F', ',', '-c', query], + capture=True, check=False) + return result.stdout.strip() if result.returncode == 0 else 'unavailable' + + +def scenario(name, replicas, total_cpu, total_mem, duration, concurrency): + source = BASE_ENV.read_text(encoding='utf-8') + db_user = env_value(source, 'POSTGRES_USER', 'messenger') + db_name = env_value(source, 'POSTGRES_DB', 'messenger') + api_cpu = total_cpu / replicas + api_mem_mb = total_mem // replicas + env_text = source.rstrip() + f'\nAPI_CPU_LIMIT={api_cpu:.3f}\nAPI_MEMORY_LIMIT={api_mem_mb}M\n' + env_path = OUT / ('.env-' + name) + env_path.write_text(env_text, encoding='utf-8') + compose = ['docker', 'compose', '--env-file', str(env_path), 'up', '-d', '--build', '--scale', f'api={replicas}'] + run(compose) + deadline = time.time() + 120 + while time.time() < deadline: + result = run(['docker', 'compose', '--env-file', str(env_path), 'ps', '-q', 'api'], capture=True, check=False) + ids = [line.strip() for line in result.stdout.splitlines() if line.strip()] + healthy = 0 + for container_id in ids: + inspected = run(['docker', 'inspect', '--format', '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}', container_id], capture=True, check=False) + if inspected.returncode == 0 and inspected.stdout.strip() == 'healthy': + healthy += 1 + if len(ids) >= replicas and healthy >= replicas: + break + time.sleep(2) + else: + raise RuntimeError(f'{name}: API replicas did not become healthy') + + output = OUT / (name + '.json') + cmd = [sys.executable, 'tests/load.py', '--base-url', 'http://localhost:8080', + '--duration', str(duration), '--concurrency', str(concurrency), '--output', str(output)] + proc = subprocess.Popen(cmd, cwd=ROOT, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True) + samples = [] + while proc.poll() is None: + timestamp = time.time() + try: + samples.append({'timestamp_epoch': timestamp, 'containers': stats(), + 'postgres_active_total_max_connections': db_activity(env_path, db_user, db_name)}) + except Exception as exc: + samples.append({'timestamp_epoch': timestamp, 'stats_error': type(exc).__name__}) + time.sleep(1) + stdout = proc.stdout.read() if proc.stdout else '' + if proc.returncode != 0: + raise RuntimeError(f'load failed for {name}: {stdout}') + metrics = json.loads(output.read_text(encoding='utf-8')) + metrics.update({'scenario': name, 'api_replicas': replicas, + 'total_api_cpu_budget': total_cpu, + 'total_api_memory_budget_mb': total_mem, + 'per_replica_cpu_limit': api_cpu, + 'per_replica_memory_limit_mb': api_mem_mb, + 'container_stats_samples': samples}) + output.write_text(json.dumps(metrics, ensure_ascii=False, indent=2) + '\n', encoding='utf-8') + run(['docker', 'compose', '--env-file', str(env_path), 'down']) + return metrics + + +def main(): + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('--duration', type=int, default=30) + p.add_argument('--concurrency', type=int, default=8) + p.add_argument('--fixed-cpu', type=float, default=2.0) + p.add_argument('--fixed-memory-mb', type=int, default=2048) + p.add_argument('--expanded-cpu', type=float, nargs=3, default=[2.0, 4.0, 8.0]) + p.add_argument('--expanded-memory-mb', type=int, nargs=3, default=[2048, 4096, 8192]) + args = p.parse_args() + if not BASE_ENV.exists(): + p.error('Create .env from .env.example before running') + OUT.mkdir(parents=True, exist_ok=True) + results = [] + for n in (1, 2, 4): + results.append(scenario(f'fixed_{n}replicas', n, args.fixed_cpu, + args.fixed_memory_mb, args.duration, args.concurrency)) + for cpu, mem in zip(args.expanded_cpu, args.expanded_memory_mb): + results.append(scenario(f'expanded_4replicas_{cpu:g}cpu_{mem}mb', 4, cpu, + mem, args.duration, args.concurrency)) + with (OUT / 'summary.csv').open('w', newline='', encoding='utf-8') as f: + fields = ['scenario', 'api_replicas', 'total_api_cpu_budget', 'total_api_memory_budget_mb', + 'successful_rps', 'failed_requests', 'error_ratio', 'p50_ms', 'p95_ms', 'p99_ms'] + writer = csv.DictWriter(f, fieldnames=fields) + writer.writeheader() + for x in results: + lat = x['successful_latency_ms'] + writer.writerow({'scenario': x['scenario'], 'api_replicas': x['api_replicas'], + 'total_api_cpu_budget': x['total_api_cpu_budget'], + 'total_api_memory_budget_mb': x['total_api_memory_budget_mb'], + 'successful_rps': x['successful_rps'], 'failed_requests': x['failed_requests'], + 'error_ratio': x['error_ratio'], 'p50_ms': lat['p50'], 'p95_ms': lat['p95'], 'p99_ms': lat['p99']}) + print(f'Wrote measured results to {OUT}') + +if __name__ == '__main__': + main() diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..e9bb595c --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,17 @@ +#!/bin/sh +set -eu +: "${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID is required}" +project="${COMPOSE_PROJECT_NAME:-mtusi-lab3}" +found="" +for id in $(docker ps -q --filter "label=com.docker.compose.project=${project}" --filter "label=com.docker.compose.service=api"); do + hostname=$(docker inspect --format '{{.Config.Hostname}}' "$id") + if [ "$hostname" = "$TARGET_INSTANCE_ID" ]; then + found="$id" + break + fi +done +if [ -z "$found" ]; then + echo "No running API container matches TARGET_INSTANCE_ID" >&2 + exit 1 +fi +docker stop --time 3 "$found" >/dev/null diff --git a/scripts/wait-ready.py b/scripts/wait-ready.py new file mode 100644 index 00000000..a9006ecf --- /dev/null +++ b/scripts/wait-ready.py @@ -0,0 +1,16 @@ +#!/usr/bin/env python3 +import sys +import time +import urllib.request + +url = sys.argv[1] if len(sys.argv) > 1 else 'http://localhost:8080/health/ready' +timeout = int(sys.argv[2]) if len(sys.argv) > 2 else 30 +deadline = time.monotonic() + timeout +while time.monotonic() < deadline: + try: + with urllib.request.urlopen(url, timeout=2) as response: + if response.status == 200: + raise SystemExit(0) + except Exception: + time.sleep(0.5) +raise SystemExit('Readiness timeout: ' + url) diff --git a/tests/client.py b/tests/client.py index f0499a29..38159a0c 100644 --- a/tests/client.py +++ b/tests/client.py @@ -14,7 +14,7 @@ import uuid ROOT = Path(__file__).resolve().parents[1] LAB = json.loads((ROOT / 'lab.json').read_text())['number'] -SPEC = json.loads((ROOT / 'contracts/openapi.json').read_text()) +SPEC = json.loads((ROOT / 'contracts/openapi.json').read_text(encoding='utf-8')) class Failure(AssertionError): pass diff --git a/tests/resilience.py b/tests/resilience.py index f3fa700a..a0c1736a 100644 --- a/tests/resilience.py +++ b/tests/resilience.py @@ -55,7 +55,7 @@ def main(): check(len(observed)>=2,'less than two API instances observed before failure; verify LB/session affinity') print('Executing explicit '+args.mode+' hook; hook output suppressed to avoid leaking secrets.') # No shell interpolation and no Docker commands in this test. - proc = subprocess.Popen([str(script)],env=env,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL) + proc = subprocess.Popen([os.environ.get("BASH_EXE", "bash"), str(script)],env=env,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL) started = time.monotonic() successes,failures,after_instances = [],0,[] try: -- 2.54.0