ЛР2 - Зюлина - на 4 #71

Closed
Zyulina_Ekaterina wants to merge 1 commits from Zyulina_Ekaterina/mtusi2026lab2-fork:solution/БВТ2302-zyulina into master
26 changed files with 1283 additions and 34 deletions
+9 -1
View File
@@ -1,6 +1,14 @@
.venv/
__pycache__/
*.pyc
.env
.git
.github
.env
tests/
student-tests/
evidence/
examples/
*.md
.env.*
!.env.example
secrets
+5 -9
View File
@@ -1,11 +1,7 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
# Copy to .env and replace the password with a unique local random value.
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
POSTGRES_USER=messenger
POSTGRES_PASSWORD=replace-with-a-random-32-character-value
POSTGRES_DB=messenger
CACHE_URL=redis://redis:6379/0
+1
View File
@@ -1,3 +1,4 @@
*.pyc
# Local/private state
.env
.env.*
+23
View File
@@ -0,0 +1,23 @@
FROM python:3.11.10-slim-bookworm
WORKDIR /app
# Устанавливаем зависимости
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Копируем код приложения
COPY src/ ./src/
COPY alembic/ ./alembic/
COPY alembic.ini .
COPY entrypoint.sh .
RUN chmod +x entrypoint.sh
# Открываем порт
EXPOSE 8080
ENTRYPOINT ["./entrypoint.sh"]
# Команда запуска
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"]
+5 -1
View File
@@ -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-level4
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "test-level4: Redis, expiry, failures, registration race, rollback, and history index"
check:
$(PYTHON) scripts/check_contract.py
@@ -24,3 +25,6 @@ load:
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-level4:
$(PYTHON) tests/level4.py --base-url "$(BASE_URL)" $(TLS_ARGS)
+79 -23
View File
@@ -1,37 +1,93 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Зюлина Екатерина Михайловна БВТ2302.
- Целевая оценка: **4**.
- Использованные источники и помощь: задание, контракт и публичные проверки этого репозитория; помощь Codex при анализе требований, реализации и подготовке отчёта.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
## Воспроизводимый запуск (Windows PowerShell)
## Архитектура и решения
Нужны Docker Desktop с Linux containers и Python 3.11. Приложение собирается из этого репозитория; миграции применяются автоматически при старте API. В новом clone подготовьте виртуальное окружение и локальный `.env`:
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```powershell
Copy-Item .env.example .env
# В .env заменить POSTGRES_PASSWORD случайным значением длиной не менее 32 символов.
py -3.11 -m venv .venv
.\.venv\Scripts\python.exe -m pip install -r requirements-dev.txt
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
$ready = $false; $deadline = (Get-Date).AddMinutes(2); while (-not $ready -and (Get-Date) -lt $deadline) { try { $ready = (Invoke-WebRequest http://localhost:8080/health/ready -UseBasicParsing -TimeoutSec 2).StatusCode -eq 200 } catch { Start-Sleep -Seconds 2 } }; if (-not $ready) { throw 'API did not become ready' }
.\.venv\Scripts\python.exe scripts\check_contract.py
.\.venv\Scripts\python.exe scripts\validate_openapi.py
.\.venv\Scripts\python.exe tests\smoke.py --base-url http://localhost:8080
.\.venv\Scripts\python.exe tests\resilience.py --mode persistence --action-script scripts\restart.bat --base-url http://localhost:8080
.\.venv\Scripts\python.exe tests\level4.py --base-url http://localhost:8080
```
## Доказательства критериев
`scripts/restart.bat` перезапускает PostgreSQL, Redis и API без удаления volumes. Не выполняйте `docker compose down -v`, пока данные нужны: эта команда намеренно удаляет сохраняемые данные. Секреты находятся только в локальном игнорируемом `.env`.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
## Архитектура и инфраструктура
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Путь запроса: клиент → FastAPI → PostgreSQL; Redis используется API для активных сессий. PostgreSQL — **источник истины** для пользователей, хешей паролей, сессий и предметных данных (чаты, участники, сообщения). Redis — TTL-кэш сессий, не единственное хранилище токенов. Volume `postgres_data` сохраняет PostgreSQL; `redis_data` сохраняет AOF Redis. Оба хранилища подключены только во внутреннюю Compose-сеть; наружу опубликован порт API.
## Эксперименты и отказы
| Роль | Compose service / образ | Готовность и постоянные данные |
| --- | --- | --- |
| HTTP API | `api`, собирается из `Dockerfile`, `python:3.11.10-slim-bookworm` | `/health/ready` проверяет БД и Redis; исходники поставляются с репозиторием. Порт на хосте задаёт `APP_PORT` (по умолчанию 8080). |
| SQL-хранилище | `db`, `postgres:16.4-alpine` | `pg_isready`; именованный `postgres_data`; порт 5432 не публикуется на хост. |
| Кэш сессий | `redis`, `redis:7.4.2-alpine` | `PING`; именованный `redis_data`; AOF и `appendfsync always`; порт 6379 не публикуется на хост. |
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Compose использует внутренний DNS сервисов `db` и `redis`. Пароль PostgreSQL передаётся API и БД из `.env`; у Redis credentials не заданы, так как он доступен только во внутренней сети локального учебного Compose-стенда. Указанные теги образов закреплены, `latest` не используется. На машине проверки: Windows, Docker Desktop Linux Engine 26.1.4 / Compose 2.27.1, Intel Core i5-11320H, 15.8 GiB RAM. Явные CPU/RAM-лимиты контейнеров не устанавливались; результаты плана запроса относятся только к этому локальному стенду.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
Схема создаётся версионируемыми миграциями Alembic: `001` создаёт начальную структуру; `002` укрепляет временные поля, уникальность членства и индексы истории/списка чатов. Entry point ждёт PostgreSQL, затем выполняет `alembic upgrade head`. Повторный запуск не создаёт вторую схему.
## Ограничения и следующие шаги
## Модель данных и транзакции
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- `users`: уникальное имя пользователя, display name, соль и результат password KDF; пароль не сохраняется.
- `sessions`: уникальный случайный bearer-токен, пользователь и абсолютный срок `expires_at`; внешний ключ связывает с пользователем.
- `chats`, `chat_members`: чат и участники; `(chat_id,user_id)` уникален, внешние ключи не допускают отсутствующих владельцев.
- `messages`: чат, отправитель, текст и серверное время; внешние ключи связывают сообщение с чатом и пользователем.
Каждая операция Store открывает свою SQLAlchemy-сессию. Создание чата и всех участников находится в одной транзакции: неизвестный/повторный участник приводит к rollback целиком. Уникальное ограничение username разрешает гонку на стороне PostgreSQL; проигравшая регистрация преобразуется в `409`, а не в дубликат. ORM использует параметры, пул ограничен пятью постоянными и пятью overflow соединениями, заданы `pool_timeout=5`, PostgreSQL `connect_timeout=5` и `statement_timeout=5s`.
## Пароли, сессии и Redis
Пароль обрабатывается стандартной библиотекой `hashlib.scrypt`: индивидуальная случайная соль 128 бит, `N=16384`, `r=8`, `p=1`; сравнение хешей constant-time. Это медленный password KDF с солью, а не быстрый checksum. Basic принимается только на `POST /api/v1/auth/sessions`. После успешного входа сервер возвращает opaque bearer-токен с 256 битами случайности; бизнес-endpoint определяют пользователя по действующей серверной сессии, а `X-User-Id` не даёт полномочий.
При создании сессии строка сначала фиксируется в PostgreSQL, затем копируется в Redis с TTL, равным оставшемуся сроку жизни. Если Redis недоступен при создании, строка удаляется, а клиент получает `503`, чтобы не выдавать сессию без кэша. Проверка токена сначала читает Redis; cache miss обращается к PostgreSQL и заполняет Redis оставшимся TTL. PostgreSQL остаётся авторитетным и позволяет восстановить действующую сессию после потери/перезапуска Redis. Logout удаляет ключ кэша и запись источника истины. TTL не продлевается чтением или рестартом API; просроченная запись не авторизует запрос даже при задержанном физическом удалении строки.
Redis настроен на AOF с `appendfsync always`. Тест перезапускает Redis без удаления `redis_data`, затем подтверждает, что прежняя действующая сессия работает; отдельный источник истины в PostgreSQL также позволяет пересобрать ключ кэша при cache miss. Быстрая проверка TCP-порта Redis с таймаутом 0.2 секунды позволяет вернуть ограниченную ошибку при остановленном сервисе, не ожидая цикла повторных попыток клиента.
## Пагинация и индекс истории
История использует непрозрачный URL-safe cursor, связанный с chat id и содержащий `(created_at,id)`. Следующая страница фильтруется сравнением этой пары и сортируется по ней же; последний элемент предыдущей страницы не повторяется. Составной индекс `ix_messages_chat_created_id(chat_id, created_at, id)` соответствует равенству по чату, диапазону по cursor и порядку выдачи. Между HTTP-запросами нет snapshot-гарантии; контракт гарантирует обход без повторов для неизменной истории.
Тест создал отдельный синтетический чат с 12 000 сообщениями, выполнил `ANALYZE` и запрос `EXPLAIN (ANALYZE, BUFFERS)` с keyset-диапазоном и `LIMIT 50`. В сохранённом [плане запроса](evidence/history-plan.txt) PostgreSQL выбрал `Index Only Scan using ix_messages_chat_created_id`, прочитал 50 строк; указаны 6 buffer hits и execution time 0.125 ms на итоговом прогоне. Это свидетельствует об использовании подходящего индекса для данного набора и запроса, но не является нагрузочным бенчмарком или обещанием такой задержки на другом окружении.
## Результаты проверок уровня 3 и 4
| Требование | Проверка | Результат|
| --- | --- | --- |
| Контракт и структура проекта | `scripts/check_contract.py` | PASS |
| Валидность Compose | `docker compose --env-file .env config --quiet` | PASS |
| OpenAPI 3.1 и JSON Schema | `scripts/validate_openapi.py` | PASS, полная валидация; приложение не подменяется тестом схемы |
| Сквозной API smoke | `tests/smoke.py --base-url http://localhost:8080` | PASS — `lab2 public API scenario` на итоговой сборке |
| Перезапуск БД/API/Redis и сохранение данных/прежнего токена | `tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080` | PASS — данные и действующая сессия подтверждены после выполнения hook на итоговой сборке |
| Две одновременные регистрации с одним username | `tests/level4.py` | PASS: ровно `201` и `409` |
| Rollback чата с неизвестным участником | `tests/level4.py` | PASS: в списке не осталось частичного чата |
| Redis TTL, AOF и отказ сервисов | `tests/level4.py` | PASS: активные ключи в Redis; сессия доступна после restart Redis; при отключении Redis и PostgreSQL readiness и запрос с Bearer дают `503`, после возврата сервисов API снова готов |
| Истечение сессии, logout и неверный пароль | `tests/level4.py` | PASS: неверный пароль `401`, logout `204` с последующим `401`, сессия с TTL 2 секунды после ожидания даёт `401` |
| История ≥10 000 строк и индексный план | `tests/level4.py` | PASS: 12 000 синтетических строк; keyset-страница 50 записей; план использовал составной индекс, сохранён в `evidence/history-plan.txt` |
Полный дополнительный сценарий запускается командой:
```powershell
.\.venv\Scripts\python.exe tests\level4.py --base-url http://localhost:8080
```
Он управляет только `api`, `db`, `redis` этой Compose-группы, не удаляет volumes и создаёт уникальные синтетические fixtures. Для проверки истечения временно меняет `SESSION_TTL_SECONDS` в локальном `.env`, затем восстанавливает исходное содержимое файла. 12 000 сообщений и записи сценариев намеренно остаются в учебной БД. Повторный прогон добавляет новый синтетический набор.
Итог проверки уровня 4: **PASS** на итоговой сборке.
## Границы решения и вопросы к защите
Это локальный учебный стенд с синтетическими данными и HTTP на localhost. Basic кодирует, но не шифрует пароль; удалённая демонстрация требует TLS. Один Docker host и один PostgreSQL не обеспечивают HA. AOF `appendfsync always` настраивает локальную политику Redis, но не защищает от потери всего Docker host/диска; устойчивость PostgreSQL зависит от WAL и хранения volume. `EXPLAIN ANALYZE` измерен на одной машине, без повторов/статистического анализа и без сравнения индексов.
+37
View File
@@ -0,0 +1,37 @@
[alembic]
script_location = alembic
sqlalchemy.url = postgresql://postgres:postgres@db:5432/messenger
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARN
handlers = console
qualname =
[logger_sqlalchemy]
level = WARN
handlers =
qualname = sqlalchemy.engine
[logger_alembic]
level = INFO
handlers =
qualname = alembic
[handler_console]
class = StreamHandler
args = (sys.stderr,)
level = NOTSET
formatter = generic
[formatter_generic]
format = %(levelname)-5.5s [%(name)s] %(message)s
datefmt = %H:%M:%S
+46
View File
@@ -0,0 +1,46 @@
from logging.config import fileConfig
from sqlalchemy import engine_from_config
from alembic import context
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from src.database import Base, DATABASE_URL
config = context.config
config.set_main_option("sqlalchemy.url", DATABASE_URL)
if config.config_file_name is not None:
fileConfig(config.config_file_name)
target_metadata = Base.metadata
def run_migrations_offline():
url = context.config.get_main_option("sqlalchemy.url")
context.configure(
url=url,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online():
connectable = engine_from_config(
config.get_section(config.config_ini_section),
prefix="sqlalchemy.",
poolclass=None,
)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+22
View File
@@ -0,0 +1,22 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}
branch_labels = ${repr(branch_labels)}
depends_on = ${repr(depends_on)}
def upgrade():
${upgrades if upgrades else "pass"}
def downgrade():
${downgrades if downgrades else "pass"}
+70
View File
@@ -0,0 +1,70 @@
"""Initial schema
Revision ID: 001
Revises:
Create Date: 2026-10-12
"""
from alembic import op
import sqlalchemy as sa
revision = '001'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
op.create_table('users',
sa.Column('id', sa.String(), nullable=False),
sa.Column('username', sa.String(length=32), nullable=False),
sa.Column('display_name', sa.String(length=100), nullable=False),
sa.Column('password_hash', sa.String(length=255), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
sa.PrimaryKeyConstraint('id'))
op.create_index('ix_users_username', 'users', ['username'], unique=True)
op.create_table('sessions',
sa.Column('id', sa.String(), nullable=False),
sa.Column('token', sa.String(length=255), nullable=False),
sa.Column('user_id', sa.String(), nullable=False),
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
sa.ForeignKeyConstraint(['user_id'], ['users.id']),
sa.PrimaryKeyConstraint('id'))
op.create_index('ix_sessions_token', 'sessions', ['token'], unique=True)
op.create_table('chats',
sa.Column('id', sa.String(), nullable=False),
sa.Column('title', sa.String(length=100), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
sa.PrimaryKeyConstraint('id'))
op.create_table('chat_members',
sa.Column('id', sa.String(), nullable=False),
sa.Column('chat_id', sa.String(), nullable=False),
sa.Column('user_id', sa.String(), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id']),
sa.ForeignKeyConstraint(['user_id'], ['users.id']),
sa.PrimaryKeyConstraint('id'))
op.create_table('messages',
sa.Column('id', sa.String(), nullable=False),
sa.Column('chat_id', sa.String(), nullable=False),
sa.Column('sender_id', sa.String(), nullable=False),
sa.Column('text', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id']),
sa.ForeignKeyConstraint(['sender_id'], ['users.id']),
sa.PrimaryKeyConstraint('id'))
op.create_index('ix_messages_chat_created', 'messages', ['chat_id', 'created_at'])
def downgrade():
op.drop_index('ix_messages_chat_created', table_name='messages')
op.drop_table('messages')
op.drop_table('chat_members')
op.drop_table('chats')
op.drop_index('ix_sessions_token', table_name='sessions')
op.drop_table('sessions')
op.drop_index('ix_users_username', table_name='users')
op.drop_table('users')
@@ -0,0 +1,35 @@
"""Add membership uniqueness and the keyset history index.
Revision ID: 002
Revises: 001
Create Date: 2026-10-14
"""
from alembic import op
import sqlalchemy as sa
revision = '002'
down_revision = '001'
branch_labels = None
depends_on = None
def upgrade():
# Older schemas allowed nullable timestamps. Backfill before tightening the
# constraint so the migration also works on an existing populated database.
for table in ('users', 'sessions', 'chats', 'messages'):
op.execute(sa.text(f'UPDATE {table} SET created_at = CURRENT_TIMESTAMP WHERE created_at IS NULL'))
op.alter_column(table, 'created_at', existing_type=sa.DateTime(timezone=True), nullable=False)
op.create_unique_constraint('uq_chat_member', 'chat_members', ['chat_id', 'user_id'])
op.create_index('ix_chat_members_user_chat', 'chat_members', ['user_id', 'chat_id'])
op.drop_index('ix_messages_chat_created', table_name='messages')
op.create_index('ix_messages_chat_created_id', 'messages', ['chat_id', 'created_at', 'id'])
def downgrade():
op.drop_index('ix_messages_chat_created_id', table_name='messages')
op.create_index('ix_messages_chat_created', 'messages', ['chat_id', 'created_at'])
op.drop_index('ix_chat_members_user_chat', table_name='chat_members')
op.drop_constraint('uq_chat_member', 'chat_members', type_='unique')
for table in ('users', 'sessions', 'chats', 'messages'):
op.alter_column(table, 'created_at', existing_type=sa.DateTime(timezone=True), nullable=True)
+51
View File
@@ -0,0 +1,51 @@
services:
api:
build: .
environment:
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:?Create a local .env first}@db:5432/${POSTGRES_DB:-messenger}
CACHE_URL: ${CACHE_URL:-redis://redis:6379/0}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
ports:
- "${APP_PORT:-8080}:8080"
depends_on:
db:
condition: service_healthy
redis:
condition: service_healthy
restart: unless-stopped
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"]
interval: 10s
timeout: 3s
retries: 5
db:
image: postgres:16.4-alpine
environment:
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Create a local .env first}
POSTGRES_DB: ${POSTGRES_DB:-messenger}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"]
interval: 5s
timeout: 5s
retries: 10
restart: unless-stopped
redis:
image: redis:7.4.2-alpine
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
restart: unless-stopped
volumes:
postgres_data:
redis_data:
+19
View File
@@ -0,0 +1,19 @@
#!/bin/sh
set -eu
python - <<'PY'
import os, time
from sqlalchemy import create_engine, text
url = os.environ["DATABASE_URL"]
engine = create_engine(url, connect_args={"connect_timeout": 3})
for attempt in range(60):
try:
with engine.connect() as connection:
connection.execute(text("SELECT 1"))
break
except Exception:
if attempt == 59:
raise
time.sleep(1)
PY
alembic upgrade head
exec "$@"
+17
View File
@@ -0,0 +1,17 @@
Synthetic chat rows: 12000
Query: keyset range on (created_at, id), LIMIT 50
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..32.35 rows=50 width=45) (actual time=0.038..0.052 rows=50 loops=1)
Buffers: shared hit=7
-> Index Only Scan using ix_messages_chat_created_id on messages (cost=0.42..959.48 rows=1502 width=45) (actual time=0.037..0.049 rows=50 loops=1)
Index Cond: ((chat_id = '16e6e2a6-54aa-4985-b7c0-9f0e0ecb0047'::text) AND (ROW(created_at, id) > ROW((CURRENT_TIMESTAMP - '01:40:00'::interval), ''::text)))
Heap Fetches: 50
Buffers: shared hit=7
Planning:
Buffers: shared hit=136
Planning Time: 0.620 ms
Execution Time: 0.111 ms
(10 rows)
+7
View File
@@ -0,0 +1,7 @@
fastapi==0.109.0
uvicorn[standard]==0.27.0
pydantic==2.5.3
sqlalchemy==2.0.25
alembic==1.13.1
psycopg2-binary==2.9.9
redis==5.0.1
+11
View File
@@ -0,0 +1,11 @@
@echo off
setlocal
cd /d "%~dp0.."
docker compose --env-file .env restart db
if errorlevel 1 exit /b 1
docker compose --env-file .env restart redis
if errorlevel 1 exit /b 1
docker compose --env-file .env restart api
if errorlevel 1 exit /b 1
powershell -NoProfile -Command "$deadline=(Get-Date).AddSeconds(90); do { try { $r=Invoke-WebRequest -UseBasicParsing http://localhost:8080/health/ready -TimeoutSec 2; if ($r.StatusCode -eq 200) { exit 0 } } catch {}; Start-Sleep -Seconds 2 } while ((Get-Date) -lt $deadline); exit 1"
exit /b %ERRORLEVEL%
+16
View File
@@ -0,0 +1,16 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart db
docker compose --env-file .env up -d --wait db
docker compose --env-file .env restart redis
docker compose --env-file .env up -d --wait redis
docker compose --env-file .env restart api
deadline=$(( $(date +%s) + 90 ))
until curl --fail --silent http://localhost:8080/health/ready >/dev/null; do
if [ "$(date +%s)" -ge "$deadline" ]; then
echo "API did not become ready within 90 seconds" >&2
exit 1
fi
sleep 2
done
+1
View File
@@ -0,0 +1 @@
from .main import app
+31
View File
@@ -0,0 +1,31 @@
"""scrypt password KDF and opaque, cryptographically random bearer tokens."""
import base64
import hashlib
import hmac
import os
import secrets
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
def hash_password(password: str) -> str:
salt = secrets.token_bytes(16)
digest = hashlib.scrypt(password.encode("utf-8"), salt=salt, n=2**14, r=8, p=1, dklen=32)
return "scrypt$16384$8$1$" + base64.urlsafe_b64encode(salt + digest).decode("ascii")
def verify_password(password: str, encoded: str) -> bool:
try:
scheme, n, r, p, raw = encoded.split("$", 4)
if scheme != "scrypt":
return False
data = base64.urlsafe_b64decode(raw.encode("ascii"))
salt, expected = data[:16], data[16:]
actual = hashlib.scrypt(password.encode("utf-8"), salt=salt, n=int(n), r=int(r), p=int(p), dklen=len(expected))
return hmac.compare_digest(actual, expected)
except (ValueError, TypeError):
return False
def new_token() -> str:
return secrets.token_urlsafe(32)
+67
View File
@@ -0,0 +1,67 @@
"""PostgreSQL schema and bounded connection pool."""
import os
import uuid
from datetime import datetime, timezone
from sqlalchemy import (Column, DateTime, ForeignKey, Index, String, Text,
UniqueConstraint, create_engine)
from sqlalchemy.orm import declarative_base, relationship, sessionmaker
DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://postgres:postgres@db:5432/messenger")
engine = create_engine(DATABASE_URL, pool_size=5, max_overflow=5, pool_timeout=5,
pool_pre_ping=True, connect_args={"connect_timeout": 5,
"options": "-c statement_timeout=5000"})
SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
Base = declarative_base()
now = lambda: datetime.now(timezone.utc)
class User(Base):
__tablename__ = "users"
id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
username = Column(String(32), nullable=False)
display_name = Column(String(100), nullable=False)
password_hash = Column(String(255), nullable=False)
created_at = Column(DateTime(timezone=True), nullable=False, default=now)
__table_args__ = (Index("ix_users_username", "username", unique=True),)
class Session(Base):
__tablename__ = "sessions"
id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
token = Column(String(255), nullable=False)
user_id = Column(String, ForeignKey("users.id"), nullable=False)
expires_at = Column(DateTime(timezone=True), nullable=False)
created_at = Column(DateTime(timezone=True), nullable=False, default=now)
user = relationship("User")
__table_args__ = (Index("ix_sessions_token", "token", unique=True),)
class Chat(Base):
__tablename__ = "chats"
id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
title = Column(String(100), nullable=False)
created_at = Column(DateTime(timezone=True), nullable=False, default=now)
members = relationship("ChatMember", back_populates="chat", cascade="all, delete-orphan")
class ChatMember(Base):
__tablename__ = "chat_members"
id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
chat_id = Column(String, ForeignKey("chats.id"), nullable=False)
user_id = Column(String, ForeignKey("users.id"), nullable=False)
chat = relationship("Chat", back_populates="members")
user = relationship("User")
__table_args__ = (UniqueConstraint("chat_id", "user_id", name="uq_chat_member"),
Index("ix_chat_members_user_chat", "user_id", "chat_id"))
class Message(Base):
__tablename__ = "messages"
id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
chat_id = Column(String, ForeignKey("chats.id"), nullable=False)
sender_id = Column(String, ForeignKey("users.id"), nullable=False)
text = Column(Text, nullable=False)
created_at = Column(DateTime(timezone=True), nullable=False, default=now)
chat = relationship("Chat")
sender = relationship("User")
__table_args__ = (Index("ix_messages_chat_created_id", "chat_id", "created_at", "id"),)
+233
View File
@@ -0,0 +1,233 @@
"""Lab 2 REST API: PostgreSQL-backed records and opaque bearer sessions."""
import base64
import binascii
import uuid
from datetime import timezone
from fastapi import FastAPI, Request, Query
from fastapi.responses import JSONResponse
from fastapi.exceptions import RequestValidationError
from sqlalchemy import text
from sqlalchemy.exc import SQLAlchemyError
from .database import SessionLocal
from .models import CreateUser, CreateChat, CreateMessage
from .store import store, cursor_for_chat, cursor_for_message
from . import session_cache
class AppError(Exception):
def __init__(self, status, code, message, headers=None):
self.status, self.code, self.message, self.headers = status, code, message, headers or {}
app = FastAPI(title="MTUSI Messenger", version="2.0.0")
@app.middleware("http")
async def request_headers(request: Request, call_next):
request.state.request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
response = await call_next(request)
response.headers["X-Request-Id"] = request.state.request_id
return response
@app.exception_handler(AppError)
async def app_error_handler(request, exc):
headers = {"X-Request-Id": request.state.request_id, **exc.headers}
return JSONResponse(status_code=exc.status, content={"error":{"code":exc.code,"message":exc.message,"request_id":request.state.request_id}}, headers=headers)
@app.exception_handler(RequestValidationError)
async def validation_handler(request, exc):
return JSONResponse(status_code=400, content={"error":{"code":"invalid_request","message":"Invalid request","request_id":request.state.request_id}}, headers={"X-Request-Id":request.state.request_id})
@app.exception_handler(SQLAlchemyError)
async def database_error_handler(request, exc):
return JSONResponse(status_code=503, content={"error":{"code":"unavailable","message":"Database unavailable","request_id":request.state.request_id}}, headers={"X-Request-Id":request.state.request_id})
@app.exception_handler(Exception)
async def internal_handler(request, exc):
return JSONResponse(status_code=500, content={"error":{"code":"internal_error","message":"Internal server error","request_id":request.state.request_id}}, headers={"X-Request-Id":request.state.request_id})
def stamp(value):
if value.tzinfo is None:
value = value.replace(tzinfo=timezone.utc)
return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
def user_json(user):
return {"id":user.id,"username":user.username,"display_name":user.display_name,"created_at":stamp(user.created_at)}
def auth_user(request):
header = request.headers.get("Authorization", "")
if not header.startswith("Bearer ") or not header[7:]:
raise AppError(401,"unauthorized","Authentication required",{"WWW-Authenticate":'Bearer realm="messenger"'})
try:
found = store.get_session_by_token(header[7:])
except session_cache.CacheUnavailable:
raise AppError(503,"unavailable","Session cache unavailable")
except SQLAlchemyError:
raise AppError(503,"unavailable","Authentication store unavailable")
if not found:
raise AppError(401,"unauthorized","Invalid or expired session",{"WWW-Authenticate":'Bearer realm="messenger"'})
return found[0]
def chat_json(chat):
return {"id":chat.id,"title":chat.title,"member_ids":[m.user_id for m in chat.members],"created_at":stamp(chat.created_at)}
def validate_uuid(value):
try:
uuid.UUID(value)
except (ValueError, AttributeError):
raise AppError(400,"invalid_request","Invalid UUID")
@app.get("/health/live")
async def live():
return {"status":"ok"}
@app.get("/health/ready")
async def ready():
try:
with SessionLocal() as db:
db.execute(text("SELECT 1"))
session_cache.ping()
return {"status":"ok"}
except session_cache.CacheUnavailable:
raise AppError(503,"unavailable","Session cache unavailable")
except SQLAlchemyError:
raise AppError(503,"unavailable","Database unavailable")
@app.post("/api/v1/users", status_code=201)
async def register(data: CreateUser):
if not data.display_name.strip() or not 12 <= len(data.password) <= 128:
raise AppError(400,"invalid_request","Invalid user fields")
try:
return user_json(store.add_user(data.username,data.display_name,data.password))
except ValueError as exc:
if str(exc) == "USERNAME_EXISTS":
raise AppError(409,"conflict","Username already exists")
raise AppError(400,"invalid_request","Invalid user fields")
except SQLAlchemyError:
raise AppError(503,"unavailable","Database unavailable")
@app.post("/api/v1/auth/sessions", status_code=201)
async def login(request: Request):
header = request.headers.get("Authorization", "")
challenge = {'WWW-Authenticate':'Basic realm="messenger", charset="UTF-8"'}
if not header.startswith("Basic "):
raise AppError(401,"unauthorized","Invalid credentials",challenge)
try:
decoded = base64.b64decode(header[6:], validate=True).decode("utf-8")
username, password = decoded.split(":", 1)
except (binascii.Error, UnicodeError, ValueError):
raise AppError(401,"unauthorized","Invalid credentials",challenge)
try:
user = store.verify_user_password(username,password)
if not user:
raise AppError(401,"unauthorized","Invalid credentials",challenge)
session = store.create_session(user.id)
return {"token":session.token,"token_type":"Bearer","expires_at":stamp(session.expires_at),"user":user_json(user)}
except session_cache.CacheUnavailable:
raise AppError(503,"unavailable","Session cache unavailable")
except SQLAlchemyError:
raise AppError(503,"unavailable","Database unavailable")
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def logout(request: Request):
auth_user(request)
try:
store.delete_session(request.headers["Authorization"][7:])
except session_cache.CacheUnavailable:
raise AppError(503,"unavailable","Session cache unavailable")
except SQLAlchemyError:
raise AppError(503,"unavailable","Authentication store unavailable")
return None
@app.get("/api/v1/users/me")
async def me(request: Request):
user_id = auth_user(request)
user = store.get_user_by_id(user_id)
if not user:
raise AppError(401,"unauthorized","Invalid session",{'WWW-Authenticate':'Bearer realm="messenger"'})
return user_json(user)
@app.post("/api/v1/chats", status_code=201)
async def create_chat(data: CreateChat, request: Request):
user_id = auth_user(request)
if not data.title.strip():
raise AppError(400,"invalid_request","Invalid title")
try:
return chat_json(store.create_chat(data.title,data.member_ids,user_id))
except ValueError as exc:
if str(exc)=="USER_NOT_FOUND":
raise AppError(400,"invalid_request","Unknown member")
raise AppError(400,"invalid_request","Invalid members")
except SQLAlchemyError:
raise AppError(503,"unavailable","Database unavailable")
@app.get("/api/v1/chats")
async def list_chats(request: Request, limit: int = Query(50,ge=1,le=100), cursor: str|None=None):
user_id=auth_user(request)
try:
rows=store.get_user_chats(user_id,cursor,limit+1)
except ValueError:
raise AppError(400,"invalid_request","Invalid cursor")
more=len(rows)>limit
rows=rows[:limit]
return {"items":[chat_json(c) for c in rows],"next_cursor":cursor_for_chat(rows[-1]) if more else None}
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(chat_id: str, request: Request):
user_id=auth_user(request)
validate_uuid(chat_id)
if not store.is_chat_member(chat_id,user_id):
raise AppError(404,"not_found","Chat not found")
chat=store.get_chat(chat_id)
if not chat:
raise AppError(404,"not_found","Chat not found")
return chat_json(chat)
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def create_message(chat_id: str, data: CreateMessage, request: Request):
user_id=auth_user(request)
validate_uuid(chat_id)
if data.text is None or len(data.text)>4000 or not data.text.strip():
raise AppError(400,"invalid_request","Invalid message text")
try:
msg=store.add_message(chat_id,user_id,data.text)
return {"id":msg.id,"chat_id":msg.chat_id,"sender_id":msg.sender_id,"text":msg.text,"created_at":stamp(msg.created_at)}
except ValueError:
raise AppError(404,"not_found","Chat not found")
except SQLAlchemyError:
raise AppError(503,"unavailable","Database unavailable")
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(chat_id: str, request: Request, limit: int=Query(50,ge=1,le=100), cursor: str|None=None):
user_id=auth_user(request)
validate_uuid(chat_id)
if not store.is_chat_member(chat_id,user_id):
raise AppError(404,"not_found","Chat not found")
try:
rows=store.get_messages(chat_id,cursor,limit+1)
except ValueError:
raise AppError(400,"invalid_request","Invalid cursor")
more=len(rows)>limit
rows=rows[:limit]
items=[{"id":m.id,"chat_id":m.chat_id,"sender_id":m.sender_id,"text":m.text,"created_at":stamp(m.created_at)} for m in rows]
return {"items":items,"next_cursor":cursor_for_message(rows[-1]) if more else None}
+27
View File
@@ -0,0 +1,27 @@
from pydantic import BaseModel, Field, ConfigDict
from typing import List
# ==================== REQUEST MODELS ====================
class CreateUser(BaseModel):
model_config = ConfigDict(extra="forbid", str_strip_whitespace=False)
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)
class CreateChat(BaseModel):
model_config = ConfigDict(extra="forbid")
title: str = Field(..., min_length=1, max_length=100)
member_ids: List[str] = Field(..., min_length=1, max_length=100)
class CreateMessage(BaseModel):
model_config = ConfigDict(extra="forbid")
text: str = Field(..., min_length=1, max_length=4000)
class LoginRequest(BaseModel):
username: str
password: str
+72
View File
@@ -0,0 +1,72 @@
"""Redis TTL cache for active sessions; PostgreSQL remains authoritative."""
import os
import socket
from urllib.parse import urlparse
from redis import Redis
from redis.backoff import NoBackoff
from redis.exceptions import RedisError
from redis.retry import Retry
CACHE_URL = os.getenv("CACHE_URL", "redis://redis:6379/0")
_cache_address = urlparse(CACHE_URL)
_cache_host = _cache_address.hostname or "redis"
_cache_port = _cache_address.port or (6380 if _cache_address.scheme == "rediss" else 6379)
try:
_cache_ips = tuple(dict.fromkeys(item[4][0] for item in socket.getaddrinfo(
_cache_host, _cache_port, type=socket.SOCK_STREAM)))
except OSError:
_cache_ips = (_cache_host,)
client = Redis.from_url(CACHE_URL, decode_responses=True,
socket_connect_timeout=0.2, socket_timeout=0.2,
health_check_interval=15, retry=Retry(NoBackoff(), 0))
class CacheUnavailable(Exception):
"""The required session cache cannot be reached within its short timeout."""
def _check_port():
# Fail fast when the Redis container is stopped. redis-py may otherwise
# spend several seconds cycling through connection retries on Docker DNS.
try:
for address in _cache_ips:
try:
with socket.create_connection((address, _cache_port), timeout=0.2):
return
except OSError:
continue
raise OSError("Redis is not accepting connections")
except OSError as exc:
raise CacheUnavailable from exc
def get(token: str):
try:
_check_port()
return client.get("session:" + token)
except RedisError as exc:
raise CacheUnavailable from exc
def put(token: str, user_id: str, ttl_seconds: int):
try:
_check_port()
client.set("session:" + token, user_id, ex=max(1, ttl_seconds))
except RedisError as exc:
raise CacheUnavailable from exc
def delete(token: str):
try:
_check_port()
client.delete("session:" + token)
except RedisError as exc:
raise CacheUnavailable from exc
def ping():
try:
_check_port()
return bool(client.ping())
except RedisError as exc:
raise CacheUnavailable from exc
+161
View File
@@ -0,0 +1,161 @@
"""Small repository layer; each operation owns and closes its DB transaction."""
import base64
import json
import uuid
from datetime import datetime, timezone, timedelta
import math
from sqlalchemy import and_, or_
from sqlalchemy.orm import selectinload
from sqlalchemy.exc import IntegrityError
from .database import User, Session as SessionRow, Chat, ChatMember, Message, SessionLocal
from .auth import hash_password, verify_password, new_token, SESSION_TTL_SECONDS
from . import session_cache
class Store:
def add_user(self, username, display_name, password):
with SessionLocal() as db:
user = User(username=username, display_name=display_name, password_hash=hash_password(password))
db.add(user)
try:
db.commit()
except IntegrityError:
db.rollback()
raise ValueError("USERNAME_EXISTS")
db.refresh(user)
return user
def get_user_by_id(self, user_id):
with SessionLocal() as db:
return db.query(User).filter(User.id == user_id).first()
def verify_user_password(self, username, password):
with SessionLocal() as db:
user = db.query(User).filter(User.username == username).first()
# A fixed dummy hash is avoided here; the public contract only requires
# identical response status and challenge for unknown users/bad passwords.
if not user or not verify_password(password, user.password_hash):
return None
return user
def create_session(self, user_id):
with SessionLocal() as db:
row = SessionRow(token=new_token(), user_id=user_id,
expires_at=datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS))
db.add(row)
db.commit()
db.refresh(row)
try:
session_cache.put(row.token, row.user_id, SESSION_TTL_SECONDS)
except session_cache.CacheUnavailable:
db.delete(row)
db.commit()
raise
return row
def get_session_by_token(self, token):
cached_user_id = session_cache.get(token)
if cached_user_id:
return (cached_user_id, None)
with SessionLocal() as db:
row = db.query(SessionRow).filter(SessionRow.token == token,
SessionRow.expires_at > datetime.now(timezone.utc)).first()
if not row:
return None
remaining = math.ceil((row.expires_at - datetime.now(timezone.utc)).total_seconds())
session_cache.put(row.token, row.user_id, remaining)
return (row.user_id, row.expires_at)
def delete_session(self, token):
# Require successful cache invalidation before reporting a completed logout.
session_cache.delete(token)
with SessionLocal() as db:
row = db.query(SessionRow).filter(SessionRow.token == token).first()
if row:
db.delete(row)
db.commit()
return True
return False
def create_chat(self, title, member_ids, creator_id):
if creator_id not in member_ids:
raise ValueError("CREATOR_NOT_MEMBER")
if len(member_ids) != len(set(member_ids)):
raise ValueError("DUPLICATE_MEMBER")
with SessionLocal() as db:
users = db.query(User.id).filter(User.id.in_(member_ids)).all()
if len(users) != len(member_ids):
raise ValueError("USER_NOT_FOUND")
chat = Chat(title=title)
chat.members = [ChatMember(user_id=mid) for mid in member_ids]
db.add(chat)
db.commit()
db.refresh(chat)
list(chat.members)
return chat
def get_chat(self, chat_id):
with SessionLocal() as db:
return db.query(Chat).options(selectinload(Chat.members)).filter(Chat.id == chat_id).first()
def get_user_chats(self, user_id, cursor=None, limit=50):
with SessionLocal() as db:
query = db.query(Chat).options(selectinload(Chat.members)).join(ChatMember).filter(ChatMember.user_id == user_id)
if cursor:
decoded = decode_cursor(cursor, "chats")
query = query.filter(or_(Chat.created_at > decoded[0], and_(Chat.created_at == decoded[0], Chat.id > decoded[1])))
rows = query.order_by(Chat.created_at, Chat.id).limit(limit).all()
for row in rows:
list(row.members)
return rows
def is_chat_member(self, chat_id, user_id):
with SessionLocal() as db:
return db.query(ChatMember.id).filter(ChatMember.chat_id == chat_id, ChatMember.user_id == user_id).first() is not None
def add_message(self, chat_id, sender_id, text):
with SessionLocal() as db:
if not db.query(Chat.id).filter(Chat.id == chat_id).first():
raise ValueError("CHAT_NOT_FOUND")
if not db.query(ChatMember.id).filter(ChatMember.chat_id == chat_id, ChatMember.user_id == sender_id).first():
raise ValueError("NOT_MEMBER")
msg = Message(chat_id=chat_id, sender_id=sender_id, text=text)
db.add(msg)
db.commit()
db.refresh(msg)
return msg
def get_messages(self, chat_id, cursor=None, limit=50):
with SessionLocal() as db:
query = db.query(Message).filter(Message.chat_id == chat_id)
if cursor:
created, message_id = decode_cursor(cursor, chat_id)
query = query.filter(or_(Message.created_at > created,
and_(Message.created_at == created, Message.id > message_id)))
return query.order_by(Message.created_at, Message.id).limit(limit).all()
def encode_cursor(resource, created_at, item_id):
raw = json.dumps([resource, created_at.isoformat(), item_id], separators=(",", ":")).encode()
return base64.urlsafe_b64encode(raw).decode().rstrip("=")
def decode_cursor(cursor, resource):
try:
data = json.loads(base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4)))
if data[0] != resource:
raise ValueError
return datetime.fromisoformat(data[1]), data[2]
except Exception:
raise ValueError("INVALID_CURSOR")
def cursor_for_chat(chat):
return encode_cursor("chats", chat.created_at, chat.id)
def cursor_for_message(message):
return encode_cursor(message.chat_id, message.created_at, message.id)
store = Store()
+10
View File
@@ -24,6 +24,16 @@ make test-persistence ACTION_SCRIPT=scripts/restart.sh
Тест создаёт данные и сессию, запускает указанный файл без shell interpolation, ожидает готовности и проверяет те же данные **с прежним токеном**. В lab4+ также проверяется исходный файл. Hook может работать до 90 секунд, готовность затем ожидается до 90 секунд. TTL сессии для этого теста — минимум 300 секунд. Успех не доказывает, что hook действительно перезапустил БД: приложите команды/состояния контейнеров до и после.
## Дополнительные проверки уровня 4, lab2
Стенд должен быть запущен через Compose с Redis, а локальный `.env` — содержать корректные настройки. Проверка управляет только сервисами `redis`, `db` и `api` этой Compose-группы; Docker volume не удаляется. Используются уникальные синтетические пользователи и чат, а индексный сценарий добавляет 12 000 синтетических сообщений в PostgreSQL. Эти fixtures остаются в стенде для возможности осмотра.
```sh
make test-level4 BASE_URL=http://localhost:8080
```
Сценарий автоматически проверяет гонку двух одинаковых регистраций, отсутствие частичного чата при ошибке состава участников, наличие ключей сессий в Redis, неверный пароль, logout, истечение сессии при TTL=2 секунды, поведение API при остановке Redis и PostgreSQL, восстановление существующей сессии после restart Redis, а также `EXPLAIN (ANALYZE, BUFFERS)` keyset-запроса на 12 000 строк. Во время короткого TTL сценария скрипт временно меняет `SESSION_TTL_SECONDS` в локальном `.env`, перезапускает API и восстанавливает исходный файл даже при ошибке теста. План сохраняется в `evidence/history-plan.txt`.
## Проверка отказа, lab3+
Реализуйте `scripts/stop-one.sh` на основе примера. `TARGET_INSTANCE_ID` в окружении содержит alias обслужившей тест API-реплики: сопоставьте его своему контейнеру/Swarm task и остановите именно его. Скрипт должен быстро вернуть 0 и **оставить эту реплику остановленной**; восстановление выполняйте отдельно. Swarm может создать новую task с другим ID — это допустимо.
+228
View File
@@ -0,0 +1,228 @@
#!/usr/bin/env python3
"""Automated lab 2 level-4 checks; operates only on synthetic test records."""
import base64
import concurrent.futures
import json
import os
from pathlib import Path
import subprocess
import time
import urllib.error
import urllib.request
import uuid
from client import Client, Failure, arguments, check, run
ROOT = Path(__file__).resolve().parents[1]
ENV_FILE = ROOT / '.env'
def compose(*args, check_ok=True):
result = subprocess.run(['docker', 'compose', '--env-file', '.env', *args],
cwd=ROOT, capture_output=True, text=True)
if check_ok and result.returncode:
raise Failure('docker compose operation failed: ' + ' '.join(args))
return result
def wait_ready(client, timeout=90):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
client.call('GET', '/health/ready', schema='Health')
return
except Failure:
time.sleep(0.5)
raise Failure('API did not recover within the readiness deadline')
def parse_env(raw):
result = {}
for line in raw.decode('ascii').splitlines():
if '=' in line and not line.lstrip().startswith('#'):
key, value = line.split('=', 1)
result[key] = value
return result
def write_env(values):
ENV_FILE.write_text(''.join(f'{key}={value}\n' for key, value in values.items()), encoding='ascii')
def registration_race(client):
username = 'race_' + uuid.uuid4().hex[:16]
body = {'username': username, 'display_name': 'Concurrent synthetic user',
'password': 'Race-Pass-' + uuid.uuid4().hex}
def post_once():
request = urllib.request.Request(client.base + '/api/v1/users',
data=json.dumps(body).encode('utf-8'),
headers={'Content-Type': 'application/json'}, method='POST')
opener = urllib.request.build_opener()
try:
response = opener.open(request, timeout=10)
except urllib.error.HTTPError as error:
response = error
with response:
return response.status
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
statuses = sorted(executor.map(lambda _: post_once(), range(2)))
check(statuses == [201, 409], 'concurrent duplicate registration was not serialized')
def list_all_chats(client, actor):
path = '/api/v1/chats?limit=100'
rows = []
while True:
page = client.call('GET', path, actor=actor, schema='ChatPage')['json']
rows.extend(page['items'])
if page['next_cursor'] is None:
return rows
from urllib.parse import quote
path = '/api/v1/chats?limit=100&cursor=' + quote(page['next_cursor'], safe='')
def database_sql(sql, variables=None):
values = parse_env(ENV_FILE.read_bytes())
args = ['docker', 'compose', '--env-file', '.env', 'exec', '-T', 'db',
'psql', '-U', values['POSTGRES_USER'], '-d', values['POSTGRES_DB'],
'-v', 'ON_ERROR_STOP=1']
for name, value in (variables or {}).items():
args.extend(['-v', name + '=' + value])
result = subprocess.run(args, cwd=ROOT, input=sql, capture_output=True, text=True)
if result.returncode:
raise Failure('database verification query failed')
return result.stdout
def internal_status(path, token=None):
# During an unhealthy dependency state Docker Desktop may stop forwarding
# the published host port. Probe the API loopback from its own container.
code = """
import os, sys, urllib.request, urllib.error
request = urllib.request.Request('http://127.0.0.1:8080' + sys.argv[1])
token = os.getenv('CHECK_TOKEN')
if token:
request.add_header('Authorization', 'Bearer ' + token)
try:
response = urllib.request.urlopen(request, timeout=30)
print(response.status)
except urllib.error.HTTPError as error:
print(error.code)
"""
command = ['docker', 'compose', '--env-file', '.env', 'exec', '-T']
if token:
command.extend(['-e', 'CHECK_TOKEN=' + token])
command.extend(['api', 'python', '-', path])
result = subprocess.run(command, cwd=ROOT, input=code, capture_output=True, text=True, timeout=32)
if result.returncode:
raise Failure('in-container dependency probe failed: ' + result.stderr[-500:])
return int(result.stdout.strip().splitlines()[-1])
def check_index_plan(client, actor):
chat = client.call('POST', '/api/v1/chats', 201, actor=actor,
body={'title': 'synthetic index plan', 'member_ids': [actor['id']]}, schema='Chat')['json']
seed_sql = """
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid()::text, :'chat_id', :'sender_id', 'plan-probe-' || n,
CURRENT_TIMESTAMP - interval '12000 seconds' + n * interval '1 second'
FROM generate_series(1, 12000) AS n;
ANALYZE messages;
SELECT count(*) FROM messages WHERE chat_id = :'chat_id';
"""
seeded = database_sql(seed_sql, {'chat_id': chat['id'], 'sender_id': actor['id']})
check('12000' in {line.strip() for line in seeded.splitlines()},
'expected 12,000 synthetic history rows')
plan_sql = """
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, created_at FROM messages
WHERE chat_id = :'chat_id'
AND (created_at, id) > (CURRENT_TIMESTAMP - interval '6000 seconds', '')
ORDER BY created_at, id
LIMIT 50;
"""
plan = database_sql(plan_sql, {'chat_id': chat['id']})
check('ix_messages_chat_created_id' in plan, 'keyset history plan did not use the composite index')
evidence = ROOT / 'evidence' / 'history-plan.txt'
evidence.write_text('Synthetic chat rows: 12000\nQuery: keyset range on (created_at, id), LIMIT 50\n\n' + plan,
encoding='utf-8')
page = client.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=50',
actor=actor, schema='MessagePage')['json']
check(len(page['items']) == 50 and page['next_cursor'], 'keyset history did not return a next page')
def check_dependency_failures(client, actor):
compose('stop', 'redis')
try:
check(internal_status('/health/ready') == 503, 'readiness did not fail when Redis was down')
check(internal_status('/api/v1/chats', actor['token']) == 503,
'authenticated request did not fail in a bounded way when Redis was down')
finally:
compose('start', 'redis')
wait_ready(client)
# Redis AOF plus PostgreSQL source of truth must preserve/rebuild this session.
client.call('GET', '/api/v1/users/me', actor=actor, schema='User')
compose('stop', 'db')
try:
check(internal_status('/health/ready') == 503, 'readiness did not fail when PostgreSQL was down')
check(internal_status('/api/v1/chats', actor['token']) == 503,
'authenticated request did not fail when PostgreSQL was down')
finally:
compose('start', 'db')
wait_ready(client)
client.call('GET', '/api/v1/users/me', actor=actor, schema='User')
def check_short_ttl(client):
saved_env = ENV_FILE.read_bytes()
values = parse_env(saved_env)
try:
values['SESSION_TTL_SECONDS'] = '2'
write_env(values)
compose('up', '-d', '--force-recreate', 'api')
wait_ready(client)
actor = client.user('expiry')
time.sleep(3)
client.call('GET', '/api/v1/users/me', 401, actor=actor)
finally:
ENV_FILE.write_bytes(saved_env)
compose('up', '-d', '--force-recreate', 'api')
wait_ready(client)
def main():
args = arguments('Lab 2 level-4 concurrency, rollback, expiry, failure, and index checks')
client = Client(args.base_url, args.ca_file, timeout=5)
wait_ready(client)
alice, bob, _eve, chat = client.bootstrap()
bad = base64.b64encode((alice['registration']['username'] + ':wrong-password').encode()).decode()
client.call('POST', '/api/v1/auth/sessions', 401,
headers={'Authorization': 'Basic ' + bad})
registration_race(client)
before = {item['id'] for item in list_all_chats(client, alice)}
client.call('POST', '/api/v1/chats', 400, actor=alice,
body={'title': 'must rollback', 'member_ids': [alice['id'], str(uuid.uuid4())]})
after = {item['id'] for item in list_all_chats(client, alice)}
check(before == after, 'failed multi-row chat creation left a partial chat')
cache_size = compose('exec', '-T', 'redis', 'redis-cli', 'DBSIZE').stdout.strip()
check(cache_size.isdigit() and int(cache_size) > 0, 'Redis does not contain active session keys')
check_dependency_failures(client, bob)
check_index_plan(client, alice)
logout_actor = client.user('logout')
client.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=logout_actor)
client.call('GET', '/api/v1/users/me', 401, actor=logout_actor)
check_short_ttl(client)
print('PASS: level-4 Redis TTL/recovery, dependency failures, expiry/logout/bad password, '
'registration race, chat rollback, and indexed 12,000-row history.')
if __name__ == '__main__':
run(main)