From 982fe0e6d251ab26fbb9f7ccb7aeb5f797154f0f Mon Sep 17 00:00:00 2001 From: Kondrashov Nikita Date: Tue, 10 Nov 2026 23:47:45 +0300 Subject: [PATCH 1/2] [+] add project --- .env.example | 9 +- Dockerfile | 15 + Makefile | 17 +- README.md | 69 +++- REPORT.md | 37 +- app/__init__.py | 0 app/main.py | 689 +++++++++++++++++++++++++++++++++ app/migrate.py | 35 ++ app/migrations/001_initial.sql | 54 +++ app/settings.py | 54 +++ compose.yaml | 83 ++++ evidence/local-validation.txt | 64 +++ infra/README.md | 6 +- requirements.txt | 5 + scripts/benchmark_history.sql | 39 ++ scripts/restart.sh | 4 + tests/expiry.py | 48 +++ tests/grade4.py | 106 +++++ tests/transaction_rollback.py | 89 +++++ 19 files changed, 1398 insertions(+), 25 deletions(-) create mode 100644 Dockerfile create mode 100644 app/__init__.py create mode 100644 app/main.py create mode 100644 app/migrate.py create mode 100644 app/migrations/001_initial.sql create mode 100644 app/settings.py create mode 100644 compose.yaml create mode 100644 evidence/local-validation.txt create mode 100644 requirements.txt create mode 100644 scripts/benchmark_history.sql create mode 100755 scripts/restart.sh create mode 100644 tests/expiry.py create mode 100644 tests/grade4.py create mode 100644 tests/transaction_rollback.py diff --git a/.env.example b/.env.example index 714c8076..39a2f9b7 100644 --- a/.env.example +++ b/.env.example @@ -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. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..322a9ade --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/Makefile b/Makefile index 9ecb223e..fe1752e8 100644 --- a/Makefile +++ b/Makefile @@ -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 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" + @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,15 @@ 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) + +explain-history: + docker compose exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 < scripts/benchmark_history.sql diff --git a/README.md b/README.md index 0e073ff7..79102c87 100644 --- a/README.md +++ b/README.md @@ -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. Опишите таблицы, ограничения, индексы и транзакционные границы до написания запросов. Добавьте версионируемые миграции. @@ -62,9 +79,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 делает её автоматически): diff --git a/REPORT.md b/REPORT.md index e42f2b05..5cf5ca60 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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 не реализованы. diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..891af097 --- /dev/null +++ b/app/main.py @@ -0,0 +1,689 @@ +import base64 +import binascii +import hashlib +import json +import logging +import os +import re +import secrets +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 and cached.get("user_id") == str(session["user_id"]): + profile = cached.get("user") + if isinstance(profile, dict) and profile.get("id") == str(session["user_id"]): + user = profile + else: + cached = None + else: + cached = None + if not cached: + 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())) + 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") + 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} diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 00000000..559901f2 --- /dev/null +++ b/app/migrate.py @@ -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() diff --git a/app/migrations/001_initial.sql b/app/migrations/001_initial.sql new file mode 100644 index 00000000..6cccb668 --- /dev/null +++ b/app/migrations/001_initial.sql @@ -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() +); diff --git a/app/settings.py b/app/settings.py new file mode 100644 index 00000000..e473c91e --- /dev/null +++ b/app/settings.py @@ -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 diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..2f37f429 --- /dev/null +++ b/compose.yaml @@ -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 diff --git a/evidence/local-validation.txt b/evidence/local-validation.txt new file mode 100644 index 00000000..fb38c18d --- /dev/null +++ b/evidence/local-validation.txt @@ -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 после повторных стартов. diff --git a/infra/README.md b/infra/README.md index 5a39e862..610f2f40 100644 --- a/infra/README.md +++ b/infra/README.md @@ -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. Это учебная локальная конфигурация. diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..8aef0255 --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/scripts/benchmark_history.sql b/scripts/benchmark_history.sql new file mode 100644 index 00000000..0a6cf266 --- /dev/null +++ b/scripts/benchmark_history.sql @@ -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; diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..838dd4a5 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose restart postgres redis api diff --git a/tests/expiry.py b/tests/expiry.py new file mode 100644 index 00000000..b9dbf1ca --- /dev/null +++ b/tests/expiry.py @@ -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) diff --git a/tests/grade4.py b/tests/grade4.py new file mode 100644 index 00000000..1a12cefb --- /dev/null +++ b/tests/grade4.py @@ -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) diff --git a/tests/transaction_rollback.py b/tests/transaction_rollback.py new file mode 100644 index 00000000..47bbaba9 --- /dev/null +++ b/tests/transaction_rollback.py @@ -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) -- 2.54.0 From c715587f9528352efd0326584bb83f5af7eeca12 Mon Sep 17 00:00:00 2001 From: Kondrashov Nikita Date: Tue, 17 Nov 2026 17:14:28 +0300 Subject: [PATCH 2/2] [+] add project --- Makefile | 7 ++- README.md | 8 +++ app/main.py | 61 +++++++++++++++--- tests/README.md | 8 +++ tests/cache_singleflight.py | 119 ++++++++++++++++++++++++++++++++++++ 5 files changed, 192 insertions(+), 11 deletions(-) create mode 100644 tests/cache_singleflight.py diff --git a/Makefile b/Makefile index fe1752e8..b3229d7a 100644 --- a/Makefile +++ b/Makefile @@ -4,10 +4,10 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-grade4 test-expiry test-rollback explain-history +.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; test: running API; test-grade4: concurrency and dependency outages" + @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: @@ -35,5 +35,8 @@ test-expiry: 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 diff --git a/README.md b/README.md index 79102c87..8d986b6b 100644 --- a/README.md +++ b/README.md @@ -72,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 diff --git a/app/main.py b/app/main.py index 891af097..7f6e4473 100644 --- a/app/main.py +++ b/app/main.py @@ -6,6 +6,7 @@ import logging import os import re import secrets +import time import uuid from contextlib import asynccontextmanager from datetime import datetime, timedelta, timezone @@ -326,15 +327,45 @@ def authenticated_user( raise auth_error() # PostgreSQL remains authoritative for expiry and revocation. Redis avoids # a user-profile query on a cache hit. - if cached and cached.get("user_id") == str(session["user_id"]): + if cached: profile = cached.get("user") - if isinstance(profile, dict) and profile.get("id") == str(session["user_id"]): + 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 - 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 @@ -346,14 +377,26 @@ def authenticated_user( 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.set( - cache_key, - json.dumps({"user_id": str(session["user_id"]), "user": user}), - ex=remaining, + 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 write failed; continuing with PostgreSQL") + logger.warning("session cache fill lock release failed") request.state.token_hash = token_hash return user diff --git a/tests/README.md b/tests/README.md index 0dfa3f89..72b52ec9 100644 --- a/tests/README.md +++ b/tests/README.md @@ -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. Идентификаторы событий не содержат токенов или персональных данных. diff --git a/tests/cache_singleflight.py b/tests/cache_singleflight.py new file mode 100644 index 00000000..0eafb7c0 --- /dev/null +++ b/tests/cache_singleflight.py @@ -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) -- 2.54.0