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