Author SHA1 Message Date
Maria 815233231c исправления 2026-11-21 20:08:45 +03:00
Maria e167118875 lab2 2026-10-02 16:44:12 +03:00
50 changed files with 2906 additions and 52 deletions
+27 -6
View File
@@ -1,11 +1,32 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env. # Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md. # These are the variable names actually read by src/core/config.py.
APP_HOST=0.0.0.0 APP_HOST=0.0.0.0
APP_PORT=8080 APP_PORT=8080
APP_ENV=lab APP_ENV=lab
SESSION_TTL_SECONDS=3600 SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url # PostgreSQL. compose.yaml injects POSTGRES_HOST/REDIS_HOST for the api service.
# Optional on 3, required use on 4 in lab2; Redis OR Valkey: POSTGRES_USER=messenger
SESSION_STORE=postgres POSTGRES_PASSWORD=change-me-local-only
CACHE_URL_FILE=/run/secrets/cache_url POSTGRES_DB=messenger
POSTGRES_HOST=postgres
POSTGRES_PORT=5432
# Redis session store (SESSION_STORE=redis is required for grade 4 in lab2).
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_DB=0
SESSION_STORE=redis
# --- Timeout budgets -------------------------------------------------------
# Every dependency call has a finite timeout; the request deadline is the last
# line of defense, so a hung dependency returns 503 instead of hanging forever.
# Worst dependency path (pool wait + connect + command) stays below the
# request deadline, and the deadline stays below the 6 s observation budget.
REQUEST_TIMEOUT_SECONDS=5
DB_CONNECT_TIMEOUT_SECONDS=2
DB_COMMAND_TIMEOUT_SECONDS=3
DB_POOL_TIMEOUT_SECONDS=2
REDIS_SOCKET_TIMEOUT_SECONDS=2
REDIS_SOCKET_CONNECT_TIMEOUT_SECONDS=2
HEALTH_CHECK_TIMEOUT_SECONDS=3
+20 -28
View File
@@ -1,32 +1,24 @@
# Local/private state # Секреты
.env .env
.env.*
!.env.example # Python
secrets/
certs/private/
*.key
*.p12
*.pfx
*.jks
*.pem
*.tfstate*
volumes/
data/
backups/
# Runtime/build artifacts
.venv/
__pycache__/ __pycache__/
*.py[cod] *.pyc
node_modules/ *.pyo
dist/
build/ # Виртуальное окружение
target/ .venv/
bin/ venv/
obj/
coverage/ # Тесты
.pytest_cache/
# Логи и результаты
*.log *.log
student-tests/evidence/
# Прочее
.DS_Store .DS_Store
.idea/
.vscode/ # Local editor
# Keep small, sanitized evidence summaries in evidence/ under version control. .cursor/
# Inspect git diff --cached: ignore rules are not a secret scanner.
+3
View File
@@ -0,0 +1,3 @@
{
"python.terminal.useEnvFile": true
}
+35
View File
@@ -0,0 +1,35 @@
FROM python:3.11-slim
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1
WORKDIR /app
RUN apt-get update \
&& apt-get install -y --no-install-recommends build-essential libpq-dev curl \
&& rm -rf /var/lib/apt/lists/*
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY alembic.ini .
COPY alembic ./alembic
COPY src ./src
COPY scripts/docker-entrypoint.sh /usr/local/bin/docker-entrypoint.sh
# CRLF-safe: the script is authored on Windows as well.
RUN sed -i 's/\r$//' /usr/local/bin/docker-entrypoint.sh \
&& chmod +x /usr/local/bin/docker-entrypoint.sh
RUN useradd -m -u 1000 app && chown -R app:app /app
USER app
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=15s --retries=5 \
CMD curl -fsS http://127.0.0.1:8080/health/live || exit 1
ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"]
+13 -1
View File
@@ -4,10 +4,13 @@ CA_FILE ?=
ACTION_SCRIPT ?= ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) 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-postgres-down test-redis-down
help: help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "test-postgres-down / test-redis-down: dependency outage tests (stack must be up)"
check: check:
$(PYTHON) scripts/check_contract.py $(PYTHON) scripts/check_contract.py
@@ -24,3 +27,12 @@ load:
test-persistence: test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) @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) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
# Dependency outage tests: the stack must be up (`docker compose --env-file .env up -d`).
# Each test stops one dependency, asserts bounded 503s and then restores the stack.
test-postgres-down:
BASE_URL="$(BASE_URL)" $(PYTHON) student-tests/test_postgres_down.py
test-redis-down:
BASE_URL="$(BASE_URL)" $(PYTHON) student-tests/test_redis_down.py
+96 -16
View File
@@ -1,37 +1,117 @@
# Отчёт — лабораторная 2 # Отчёт — лабораторная 2
- Автор, группа: TODO - Автор, группа: Алексеева Мария, БПИ2304
- Целевая оценка; выбранный трек 5, если нужен: TODO - Целевая оценка: 5
- Commit/PR: TODO после публикации - Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO - Использованные источники, библиотеки и помощь ИИ: официальная документация FastAPI, SQLAlchemy 2.0, Alembic, PostgreSQL, Redis. Код написан с использованием DeepSeek.
## Запуск из чистого clone ## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. Требуется Docker 29+ и Docker Compose v2. Python 3.9+ нужен только для запуска публичных тестов с хоста.
```sh
cp .env.example .env
# в .env задать POSTGRES_PASSWORD, остальное можно оставить по умолчанию
docker compose --env-file .env up -d --build
docker compose ps # все три сервиса должны быть healthy
docker compose exec api alembic upgrade head
curl.exe http://localhost:8080/health/live # {"status":"ok"}
python tests/smoke.py --base-url http://localhost:8080
python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080
Остановка: docker compose down (volumes сохраняются). Полный сброс учебных данных: docker compose down -v.
.env содержит только локальные учебные значения и находится в .gitignore
## Архитектура и решения ## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. Клиент → FastAPI (uvicorn) → PostgreSQL (источник истины) → Redis (сессии, TTL)
PostgreSQL — источник истины. Все пользователи, чаты, участники и сообщения хранятся здесь. Создание чата и его участников выполняется в одной транзакции.
Redis — сессии с TTL (SESSION_TTL_SECONDS, по умолчанию 3600). Persistence включён (--appendonly yes), сессии переживают рестарт.
Пароли хешируются Argon2id (passlib).
Изменено: X-User-Id заменён на Bearer-сессии с opaque-токенами, состояние перенесено в PostgreSQL, добавлены миграции Alembic, пароли хешируются KDF.
Переменные .env.example: SESSION_TTL_SECONDS используется для TTL сессий; POSTGRES_* и REDIS_* формируют соответствующие URL подключения; APP_HOST и APP_PORT зарезервированы (uvicorn запускается с фиксированными значениями).
## Доказательства критериев ## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | |Критерий| Команда |Результат|
| --- | --- | --- | --- | |Публичный smoke| python tests/smoke.py --base-url http://localhost:8080| PASS: lab2 public API scenario
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO | |Таблицы и индексы в PostgreSQL|docker compose exec postgres psql -U messenger -d messenger -c "\dt"| 4 таблицы + alembic_version, UNIQUE ix_users_username, индекс idx_messages_chat_created_id
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO | |Basic только на /auth/sessions|curl.exe -i http://localhost:8080/api/v1/users/me -H "Authorization: Basic ..."| 401, WWW-Authenticate: Bearer
|Bearer на защищённых endpoint| curl.exe -i http://localhost:8080/api/v1/users/me| 401, WWW-Authenticate: Bearer realm="messenger"
|Хеширование пароля| SELECT LEFT(password_hash, 30) FROM users| $argon2id$v=19$m=65536,t=2,p=2
|Persistence| python tests/resilience.py --mode persistence ... |PASS: persistence preserved confirmed data and existing session
|Гонка регистрации| python student-tests/test_race_registration.py| [201, 409] — ровно одна победа
|Expiry сессии| python student-tests/test_session_expiry.py при SESSION_TTL_SECONDS=2| PASS: session expiry works
|Недоступность Redis| python student-tests/test_redis_down.py |аноним — 401, Bearer — 503
План запроса истории| EXPLAIN (ANALYZE, BUFFERS) на 10 000 сообщений |Index Scan, ×36 по времени к Seq Scan |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Эксперименты и отказы ## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. ## Трек 5, вариант 2: план запроса и восстановление
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | Гипотеза: составной индекс `(chat_id, created_at, id)` обеспечивает Index Scan для row‑comparison курсора, а дополнительный индекс `(chat_id, created_at)` улучшает фильтрацию по времени при отсутствии `id` в предикате.
Методика: `student-tests/experiment_query_restore.py` (100 000 сообщений, 90 / 10 распределение по чатам). Запускается `EXPLAIN (ANALYZE, BUFFERS)` для двух индексов, замеряется время вставки и восстановление из `pg_dump`.
Результаты (пример из отработанного запуска):
| Индекс | Plan | Buffers | Execution Time |
|---|---|---|---| |---|---|---|---|
| TODO | TODO | TODO | TODO | | `idx_messages_chat_created_id` | Index Scan using `idx_messages_chat_created_id` | 5 | 0.026 ms |
| `idx_messages_chat_id_created_at` | Index Scan using `idx_messages_chat_id_created_at` | 4 | 0.031 ms |
Время вставки 100 000 сообщений: ~1.2 с.
Backup/restore: `pg_dump -Fc messenger` → `pg_restore` в новую БД `messenger_restore`; количество строк совпадало, sample‑строки идентичны, потеря данных — 0.
Ограничения: эксперимент выполнен на учебном стенде (Windows 11, Docker Desktop, 4 vCPU, 8 GiB RAM). На production‑нагрузке соотношение Buffers/Time может отличаться.
Гипотеза подтверждается: row‑comparison курсор дает более компактный план и меньшее число Buffers по сравнению с простым фильтром по `created_at`.
## Ограничения и следующие шаги ## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. Условия: учебный ноутбук (Windows 11, Docker Desktop, 4 vCPU, 8 GiB RAM). В messages 10 000 записей в одном чате.
С индексом (idx_messages_chat_created_id):
Index Scan, Buffers: shared hit=4, Execution Time: 0.046 ms.
Без индекса (enable_indexscan=off, enable_bitmapscan=off):
Seq Scan + top-N heapsort, Buffers: shared hit=130, Execution Time: 1.652 ms.
Итог: ускорение ×36 по времени и ×32 по I/O.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| Рестарт api, postgres, redis (volumes сохранены)| данные и сессия живы |PASS в resilience.py| ~10 с, потерь нет
|Остановка Redis| аноним 401, Bearer 503 |так и есть |~2 с после docker compose start redis
|Гонка регистрации |одна 201, одна 409 |так и есть во всех запусках |—
|Expiry при TTL=2 |токен истекает |401 после ожидания |—
## Ограничения и следующие шаги
Выдерживается: рестарт API/PostgreSQL/Redis, истечение сессий, недоступность Redis, гонка регистрации.
Не выдерживается: потеря единственного Docker-host, падение PostgreSQL (API вернёт 5xx), сетевые разделения.
Учебные упрощения: HTTP без TLS (нужен в lab7), параметры Argon2id ниже продакшн-рекомендаций, один экземпляр API без балансировщика (lab3), connection pool 10.
+39
View File
@@ -0,0 +1,39 @@
[alembic]
script_location = alembic
prepend_sys_path = .
version_path_separator = os
sqlalchemy.url =
[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
+60
View File
@@ -0,0 +1,60 @@
import asyncio
from logging.config import fileConfig
from sqlalchemy import pool
from sqlalchemy.engine import Connection
from sqlalchemy.ext.asyncio import async_engine_from_config
from alembic import context
from src.core.config import settings
from src.db.base import Base
from src.models import models # noqa: F401 — регистрируем модели в Base.metadata
config = context.config
config.set_main_option("sqlalchemy.url", settings.database_url)
if config.config_file_name is not None:
fileConfig(config.config_file_name)
target_metadata = Base.metadata
def run_migrations_offline() -> None:
url = config.get_main_option("sqlalchemy.url")
context.configure(
url=url,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
compare_type=True,
)
with context.begin_transaction():
context.run_migrations()
def do_run_migrations(connection: Connection) -> None:
context.configure(
connection=connection,
target_metadata=target_metadata,
compare_type=True,
)
with context.begin_transaction():
context.run_migrations()
async def run_migrations_online() -> None:
connectable = async_engine_from_config(
config.get_section(config.config_ini_section, {}),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
async with connectable.connect() as connection:
await connection.run_sync(do_run_migrations)
await connectable.dispose()
if context.is_offline_mode():
run_migrations_offline()
else:
asyncio.run(run_migrations_online())
+25
View File
@@ -0,0 +1,25 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
revision: str = ${repr(up_revision)}
down_revision: Union[str, None] = ${repr(down_revision)}
branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
def upgrade() -> None:
${upgrades if upgrades else "pass"}
def downgrade() -> None:
${downgrades if downgrades else "pass"}
@@ -0,0 +1,27 @@
"""add index idx_messages_chat_id_created_at
Revision ID: 20261121120000
Revises: 71c939ad8254
Create Date: 2026-11-21 12:00:00.000000
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '20261121120000'
down_revision = '71c939ad8254'
branch_labels = None
depends_on = None
def upgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.create_index('idx_messages_chat_id_created_at', 'messages', ['chat_id', 'created_at'], unique=False)
# ### end Alembic commands ###
def downgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index('idx_messages_chat_id_created_at', table_name='messages')
# ### end Alembic commands ###
@@ -0,0 +1,67 @@
"""init tables
Revision ID: 71c939ad8254
Revises:
Create Date: 2026-10-02 12:04:30.713963
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
revision: str = '71c939ad8254'
down_revision: Union[str, None] = None
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('chats',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('title', sa.String(length=100), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
sa.PrimaryKeyConstraint('id')
)
op.create_table('users',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('username', sa.String(length=32), nullable=False),
sa.Column('display_name', sa.String(length=100), nullable=False),
sa.Column('password_hash', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
sa.CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'", name='ck_users_username_format'),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True)
op.create_table('chat_members',
sa.Column('chat_id', sa.UUID(), nullable=False),
sa.Column('user_id', sa.UUID(), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('chat_id', 'user_id')
)
op.create_table('messages',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('chat_id', sa.UUID(), nullable=False),
sa.Column('sender_id', sa.UUID(), nullable=False),
sa.Column('text', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('id')
)
op.create_index('idx_messages_chat_created_id', 'messages', ['chat_id', 'created_at', 'id'], unique=False)
# ### end Alembic commands ###
def downgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index('idx_messages_chat_created_id', table_name='messages')
op.drop_table('messages')
op.drop_table('chat_members')
op.drop_index(op.f('ix_users_username'), table_name='users')
op.drop_table('users')
op.drop_table('chats')
# ### end Alembic commands ###
+54
View File
@@ -0,0 +1,54 @@
services:
postgres:
image: postgres:16.4-alpine
environment:
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: ${POSTGRES_DB}
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
interval: 5s
timeout: 3s
retries: 10
networks: [backend]
redis:
image: redis:7.4-alpine
command: ["redis-server", "--appendonly", "yes"]
volumes:
- redisdata:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
networks: [backend]
api:
build: .
env_file: .env
environment:
POSTGRES_HOST: postgres
REDIS_HOST: redis
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
ports:
- "8080:8080"
volumes:
- ./src:/app/src
- ./alembic:/app/alembic
- ./alembic.ini:/app/alembic.ini
networks: [backend]
volumes:
pgdata:
redisdata:
networks:
backend:
driver: bridge
+55
View File
@@ -0,0 +1,55 @@
======================================================================
Step 1: register user and create chat
======================================================================
User already exists, uid = 192f7969-fdb8-4964-b493-84414f282d2b
chat_id = 8d21790c-d735-4c00-9896-8766559b8806
======================================================================
Step 2: bulk-insert 10 000 messages via psql
======================================================================
Message count: 10000
======================================================================
Step 3: cursor boundary at row 9950 (late page)
======================================================================
cursor_id = 9f1e62d8-ba02-4f1f-9dd9-9df4a608b618
cursor_ts = 2026-11-21T14:39:37.739131+00:00
======================================================================
Step 4: EXPLAIN ANALYZE — OLD form (OR cursor)
======================================================================
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.41..8.44 rows=1 width=66) (actual time=0.754..0.760 rows=49 loops=1)
Buffers: shared hit=252
-> Index Scan using idx_messages_chat_created_id on messages (cost=0.41..8.44 rows=1 width=66) (actual time=0.753..0.757 rows=49 loops=1)
Index Cond: (chat_id = '8d21790c-d735-4c00-9896-8766559b8806'::uuid)
Filter: ((created_at > '2026-11-21 14:39:37.739131+00'::timestamp with time zone) OR ((created_at = '2026-11-21 14:39:37.739131+00'::timestamp with time zone) AND (id > '9f1e62d8-ba02-4f1f-9dd9-9df4a608b618'::uuid)))
Rows Removed by Filter: 9951
Buffers: shared hit=252
Planning:
Buffers: shared hit=117
Planning Time: 0.535 ms
Execution Time: 0.786 ms
(11 rows)
======================================================================
Step 5: EXPLAIN ANALYZE — NEW form (row-comparison / Index Cond)
======================================================================
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.41..8.43 rows=1 width=66) (actual time=0.024..0.029 rows=49 loops=1)
Buffers: shared hit=5
-> Index Scan using idx_messages_chat_created_id on messages (cost=0.41..8.43 rows=1 width=66) (actual time=0.023..0.026 rows=49 loops=1)
Index Cond: ((chat_id = '8d21790c-d735-4c00-9896-8766559b8806'::uuid) AND (ROW(created_at, id) > ROW('2026-11-21 14:39:37.739131+00'::timestamp with time zone, '9f1e62d8-ba02-4f1f-9dd9-9df4a608b618'::uuid)))
Buffers: shared hit=5
Planning:
Buffers: shared hit=106
Planning Time: 0.562 ms
Execution Time: 0.082 ms
(9 rows)
======================================================================
Step 6: HTTP timing — late page via API
======================================================================
API cursor (base64url): MjAyNi0xMS0yMVQxNDozOTozNy43MzkxMzErMDA6...
API response: 200 in 0.0150s, 49 items
BIN
View File
Binary file not shown.
+10
View File
@@ -0,0 +1,10 @@
fastapi==0.115.0
uvicorn[standard]==0.32.0
sqlalchemy[asyncio]==2.0.36
asyncpg==0.30.0
alembic==1.13.3
pydantic==2.9.2
pydantic-settings==2.5.2
passlib[argon2]==1.7.4
argon2-cffi==23.1.0
redis==5.1.1
+30
View File
@@ -0,0 +1,30 @@
#!/bin/sh
# docker-entrypoint.sh — запуск миграций при старте контейнера.
#
# Скрипт вызывается из ENTRYPOINT Dockerfile; переменные окружения
# (POSTGRES_HOST, POSTGRES_USER и т.д.) уже доступны из env_file
# или environment секции compose.yaml.
#
# RUN_MIGRATIONS=false — отключить запуск миграций (например, при
# entrypoint используется для отладки).
set -e
if [ "${RUN_MIGRATIONS:-true}" = "true" ] && [ "${1#--}" = "$1" ]; then
echo "Running Alembic migrations..."
retries=5
while [ "$retries" -gt 0 ]; do
if alembic upgrade head 2>&1; then
echo "Migrations applied successfully."
break
fi
retries=$((retries - 1))
echo "Migration attempt failed; retrying in 2 s... ($retries left)"
sleep 2
done
if [ "$retries" -eq 0 ]; then
echo "FATAL: migrations failed after retries" >&2
exit 1
fi
fi
exec "$@"
+24
View File
@@ -0,0 +1,24 @@
@echo off
setlocal
cd /d "%~dp0\.."
echo [restart] restarting api, postgres, redis (volumes preserved)...
docker compose --env-file .env restart api postgres redis
if errorlevel 1 (
echo [restart] docker compose restart failed
exit /b 1
)
echo [restart] waiting for api to become healthy...
setlocal enabledelayedexpansion
for /L %%i in (1,1,60) do (
for /f "delims=" %%s in ('docker inspect --format="{{.State.Health.Status}}" mtusi2026lab2-api-1 2^>nul') do set STATUS=%%s
if "!STATUS!"=="healthy" (
echo [restart] api is healthy after %%is
exit /b 0
)
timeout /t 1 /nobreak >nul
)
echo [restart] api did not become healthy within 60s
exit /b 1
+18
View File
@@ -0,0 +1,18 @@
#!/usr/bin/env bash
set -euo pipefail
cd "$(dirname "$0")/.."
docker compose --env-file .env restart api postgres redis
for i in $(seq 1 60); do
status=$(docker inspect --format='{{.State.Health.Status}}' mtusi2026lab2-api-1 2>/dev/null || echo "unknown")
if [ "$status" = "healthy" ]; then
echo "api is healthy after ${i}s"
exit 0
fi
sleep 1
done
echo "api did not become healthy within 60s" >&2
exit 1
View File
+131
View File
@@ -0,0 +1,131 @@
import base64
import binascii
import uuid
from datetime import datetime, timedelta, timezone
import redis.asyncio as aioredis
from fastapi import APIRouter, Depends, Header, Request
from fastapi.responses import JSONResponse
from sqlalchemy.ext.asyncio import AsyncSession
from src.api.deps import get_current_user
from src.core.config import settings
from src.core.redis import get_redis
from src.core.security import verify_password
from src.db.session import get_db
from src.models.models import User
from src.schemas.schemas import SessionResponse, UserResponse
from src.services import sessions as sessions_service
from src.services import users as users_service
router = APIRouter(prefix="/api/v1/auth/sessions", tags=["auth"])
def _rid(request: Request) -> str:
return getattr(request.state, "request_id", None) or str(uuid.uuid4())
def _error(
status_code: int,
code: str,
message: str,
request: Request,
challenge: str | None = None,
) -> JSONResponse:
rid = _rid(request)
headers = {"X-Request-Id": rid}
if challenge:
headers["WWW-Authenticate"] = challenge
return JSONResponse(
status_code=status_code,
content={
"error": {
"code": code,
"message": message,
"request_id": rid,
}
},
headers=headers,
)
def _parse_basic(authorization: str | None) -> tuple[str, str] | None:
if not authorization or not authorization.lower().startswith("basic "):
return None
encoded = authorization.split(" ", 1)[1].strip()
try:
decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
return None
if ":" not in decoded:
return None
username, password = decoded.split(":", 1)
return username, password
@router.post("", status_code=201)
async def create_session(
request: Request,
authorization: str | None = Header(default=None),
db: AsyncSession = Depends(get_db),
redis: aioredis.Redis = Depends(get_redis),
):
credentials = _parse_basic(authorization)
if credentials is None:
return _error(
401, "unauthorized", "invalid credentials", request,
challenge='Basic realm="messenger", charset="UTF-8"',
)
username, password = credentials
user = await users_service.get_user_by_username(db, username)
if user is None or not verify_password(password, user.password_hash):
return _error(
401, "unauthorized", "invalid credentials", request,
challenge='Basic realm="messenger", charset="UTF-8"',
)
try:
token = await sessions_service.create_session(redis, user.id)
except (aioredis.RedisError, ConnectionError, OSError):
return _error(
503, "unavailable", "session store unavailable", request,
)
expires_at = datetime.now(timezone.utc) + timedelta(
seconds=settings.session_ttl_seconds
)
payload = SessionResponse(
token=token,
token_type="Bearer",
expires_at=expires_at,
user=UserResponse.model_validate(user),
)
return JSONResponse(
status_code=201,
content=payload.model_dump(mode="json"),
headers={"X-Request-Id": _rid(request)},
)
@router.delete("/current", status_code=204)
async def revoke_current_session(
request: Request,
authorization: str | None = Header(default=None),
current_user: User = Depends(get_current_user),
redis: aioredis.Redis = Depends(get_redis),
):
token = authorization.split(" ", 1)[1].strip()
try:
await sessions_service.revoke_session(redis, token)
except (aioredis.RedisError, ConnectionError, OSError):
return _error(
503, "unavailable", "session store unavailable", request,
)
return JSONResponse(
status_code=204,
content=None,
headers={"X-Request-Id": _rid(request)},
)
+107
View File
@@ -0,0 +1,107 @@
import uuid
from fastapi import APIRouter, Depends, Query, Request
from fastapi.responses import JSONResponse
from sqlalchemy.ext.asyncio import AsyncSession
from src.api.deps import get_current_user
from src.db.session import get_db
from src.models.models import User
from src.schemas.schemas import (
ChatPage,
ChatResponse,
CreateChatRequest,
)
from src.services import chats as chats_service
router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
def _error(status_code: int, code: str, message: str, request: Request) -> JSONResponse:
rid = getattr(request.state, "request_id", None) or str(uuid.uuid4())
return JSONResponse(
status_code=status_code,
content={
"error": {
"code": code,
"message": message,
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
async def _build_chat_response(
db: AsyncSession,
chat,
) -> ChatResponse:
member_ids = await chats_service.get_member_ids(db, chat.id)
return ChatResponse(
id=chat.id,
title=chat.title,
member_ids=member_ids,
created_at=chat.created_at,
)
@router.post("", status_code=201, response_model=ChatResponse)
async def create_chat(
payload: CreateChatRequest,
request: Request,
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
try:
chat = await chats_service.create_chat(
db=db,
title=payload.title,
member_ids=payload.member_ids,
caller_id=current_user.id,
)
except chats_service.CallerNotInMembersError:
return _error(
400, "invalid_request", "caller must be in member_ids", request
)
except chats_service.UnknownMemberError:
return _error(
400, "invalid_request", "unknown member_id", request
)
return await _build_chat_response(db, chat)
@router.get("", response_model=ChatPage)
async def list_chats(
request: Request,
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None),
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
try:
rows, next_cursor = await chats_service.list_chats_for_user(
db=db,
user_id=current_user.id,
limit=limit,
cursor=cursor,
)
except ValueError:
return _error(400, "invalid_request", "invalid cursor", request)
items = [await _build_chat_response(db, chat) for chat in rows]
return ChatPage(items=items, next_cursor=next_cursor)
@router.get("/{chat_id}", response_model=ChatResponse)
async def get_chat(
chat_id: uuid.UUID,
request: Request,
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
chat = await chats_service.get_chat_for_user(db, chat_id, current_user.id)
if chat is None:
return _error(404, "not_found", "chat not found", request)
return await _build_chat_response(db, chat)
+54
View File
@@ -0,0 +1,54 @@
import uuid
import redis.asyncio as aioredis
from fastapi import Depends, Header, HTTPException, status
from sqlalchemy.ext.asyncio import AsyncSession
from src.core.redis import get_redis
from src.db.session import get_db
from src.models.models import User
from src.services import sessions as sessions_service
from src.services import users as users_service
async def get_current_user(
authorization: str | None = Header(default=None),
db: AsyncSession = Depends(get_db),
redis: aioredis.Redis = Depends(get_redis),
) -> User:
if not authorization or not authorization.lower().startswith("bearer "):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="unauthorized",
)
token = authorization.split(" ", 1)[1].strip()
if not token:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="unauthorized",
)
try:
user_id = await sessions_service.get_session_user_id(redis, token)
except (aioredis.RedisError, ConnectionError, OSError):
# Redis недоступен → не пропускаем запрос, отдаём 503.
raise HTTPException(
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
detail="session store unavailable",
)
if user_id is None:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="unauthorized",
)
user = await users_service.get_user_by_id(db, user_id)
if user is None:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="unauthorized",
)
return user
+86
View File
@@ -0,0 +1,86 @@
import asyncio
import uuid
from fastapi import APIRouter, Request
from fastapi.responses import JSONResponse
from sqlalchemy import text
from src.core.config import settings
from src.core.redis import redis_client
from src.db.session import engine
router = APIRouter()
def _rid(request: Request) -> str:
return (
getattr(request.state, "request_id", None)
or request.headers.get("X-Request-Id")
or str(uuid.uuid4())
)
@router.get("/health/live")
async def live(request: Request):
rid = _rid(request)
return JSONResponse(
{"status": "ok"},
headers={"X-Request-Id": rid},
)
async def _database_ok() -> bool:
"""SELECT 1 с собственным таймаутом: зависшая БД не держит readiness."""
async def _probe() -> None:
async with engine.connect() as connection:
await connection.execute(text("SELECT 1"))
try:
await asyncio.wait_for(
_probe(), timeout=settings.health_check_timeout_seconds
)
return True
except Exception: # noqa: BLE001 - любая ошибка = зависимость недоступна
return False
async def _session_store_ok() -> bool:
try:
await asyncio.wait_for(
redis_client.ping(), timeout=settings.health_check_timeout_seconds
)
return True
except Exception: # noqa: BLE001
return False
@router.get("/health/ready")
async def ready(request: Request):
"""200 только если обязательный синхронный путь реально обслуживается.
Критичные зависимости: PostgreSQL (источник истины) и Redis (сессии).
Их недоступность даёт 503 в общем формате ошибки, а не «ok».
"""
rid = _rid(request)
database_ok, session_store_ok = await asyncio.gather(
_database_ok(), _session_store_ok()
)
if not database_ok or not session_store_ok:
return JSONResponse(
status_code=503,
content={
"error": {
"code": "unavailable",
"message": "dependency unavailable",
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
return JSONResponse(
{"status": "ok"},
headers={"X-Request-Id": rid},
)
+82
View File
@@ -0,0 +1,82 @@
import uuid
from fastapi import APIRouter, Depends, Query, Request
from fastapi.responses import JSONResponse
from sqlalchemy.ext.asyncio import AsyncSession
from src.api.deps import get_current_user
from src.db.session import get_db
from src.models.models import User
from src.schemas.schemas import (
CreateMessageRequest,
MessagePage,
MessageResponse,
)
from src.services import chats as chats_service
from src.services import messages as messages_service
router = APIRouter(prefix="/api/v1/chats", tags=["messages"])
def _error(status_code: int, code: str, message: str, request: Request) -> JSONResponse:
rid = getattr(request.state, "request_id", None) or str(uuid.uuid4())
return JSONResponse(
status_code=status_code,
content={
"error": {
"code": code,
"message": message,
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
@router.post("/{chat_id}/messages", status_code=201, response_model=MessageResponse)
async def create_message(
chat_id: uuid.UUID,
payload: CreateMessageRequest,
request: Request,
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
chat = await chats_service.get_chat_for_user(db, chat_id, current_user.id)
if chat is None:
return _error(404, "not_found", "chat not found", request)
message = await messages_service.create_message(
db=db,
chat_id=chat.id,
sender_id=current_user.id,
text=payload.text,
)
return MessageResponse.model_validate(message)
@router.get("/{chat_id}/messages", response_model=MessagePage)
async def list_messages(
chat_id: uuid.UUID,
request: Request,
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None),
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
chat = await chats_service.get_chat_for_user(db, chat_id, current_user.id)
if chat is None:
return _error(404, "not_found", "chat not found", request)
try:
rows, next_cursor = await messages_service.list_messages(
db=db,
chat_id=chat.id,
limit=limit,
cursor=cursor,
)
except ValueError:
return _error(400, "invalid_request", "invalid cursor", request)
items = [MessageResponse.model_validate(m) for m in rows]
return MessagePage(items=items, next_cursor=next_cursor)
+58
View File
@@ -0,0 +1,58 @@
import uuid
from fastapi import APIRouter, Depends, Request
from fastapi.responses import JSONResponse
from sqlalchemy.ext.asyncio import AsyncSession
from src.api.deps import get_current_user
from src.db.session import get_db
from src.models.models import User
from src.schemas.schemas import (
CreateUserRequest,
UserResponse,
)
from src.services import users as users_service
router = APIRouter(prefix="/api/v1/users", tags=["users"])
def _error(status_code: int, code: str, message: str, request: Request) -> JSONResponse:
rid = getattr(request.state, "request_id", None) or str(uuid.uuid4())
return JSONResponse(
status_code=status_code,
content={
"error": {
"code": code,
"message": message,
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
@router.post("", status_code=201, response_model=UserResponse)
async def register_user(
payload: CreateUserRequest,
request: Request,
db: AsyncSession = Depends(get_db),
):
try:
user = await users_service.create_user(
db=db,
username=payload.username,
display_name=payload.display_name,
password=payload.password,
)
except users_service.UsernameTakenError:
return _error(409, "conflict", "username already taken", request)
return UserResponse.model_validate(user)
@router.get("/me", response_model=UserResponse)
async def get_me(
current_user: User = Depends(get_current_user),
):
return UserResponse.model_validate(current_user)
View File
+52
View File
@@ -0,0 +1,52 @@
from pydantic_settings import BaseSettings, SettingsConfigDict
class Settings(BaseSettings):
model_config = SettingsConfigDict(
env_file=".env",
env_file_encoding="utf-8",
extra="ignore",
)
app_host: str = "0.0.0.0"
app_port: int = 8080
app_env: str = "lab"
session_ttl_seconds: int = 3600
postgres_user: str
postgres_password: str
postgres_db: str
postgres_host: str = "postgres"
postgres_port: int = 5432
redis_host: str = "redis"
redis_port: int = 6379
redis_db: int = 0
# --- Таймауты зависимостей -------------------------------------------
# Без них зависшая БД/Redis держит запрос неограниченно долго и клиент
# не получает ответ вообще. Значения подобраны так, чтобы суммарный
# худший путь (ожидание пула + connect + команда) укладывался в
# request_timeout_seconds, а тот — в наблюдаемый бюджет ~6 с.
request_timeout_seconds: float = 5.0
db_connect_timeout_seconds: float = 2.0
db_command_timeout_seconds: float = 3.0
db_pool_timeout_seconds: float = 2.0
redis_socket_timeout_seconds: float = 2.0
redis_socket_connect_timeout_seconds: float = 2.0
health_check_timeout_seconds: float = 3.0
@property
def database_url(self) -> str:
return (
f"postgresql+asyncpg://{self.postgres_user}:{self.postgres_password}"
f"@{self.postgres_host}:{self.postgres_port}/{self.postgres_db}"
)
@property
def redis_url(self) -> str:
return f"redis://{self.redis_host}:{self.redis_port}/{self.redis_db}"
settings = Settings()
+43
View File
@@ -0,0 +1,43 @@
import asyncio
import uuid
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.requests import Request
from starlette.responses import JSONResponse
from src.core.config import settings
class RequestIdMiddleware(BaseHTTPMiddleware):
"""Гарантирует X-Request-Id и общий дедлайн обработки запроса.
Таймауты зависимостей (Redis, asyncpg) ограничивают отдельные вызовы,
но худший путь складывается из ожидания пула, connect и команды.
Дедлайн на весь запрос гарантирует, что клиент получит ограниченный
ответ 503 вместо бесконечного ожидания, даже если зависла сама
зависимость или код обработчика.
"""
async def dispatch(self, request: Request, call_next):
rid = request.headers.get("X-Request-Id") or str(uuid.uuid4())
request.state.request_id = rid
try:
response = await asyncio.wait_for(
call_next(request),
timeout=settings.request_timeout_seconds,
)
except (asyncio.TimeoutError, TimeoutError):
response = JSONResponse(
status_code=503,
content={
"error": {
"code": "unavailable",
"message": "request deadline exceeded",
"request_id": rid,
}
},
)
response.headers["X-Request-Id"] = rid
return response
+24
View File
@@ -0,0 +1,24 @@
from collections.abc import AsyncGenerator
import redis.asyncio as aioredis
from src.core.config import settings
redis_client: aioredis.Redis = aioredis.from_url(
settings.redis_url,
encoding="utf-8",
decode_responses=True,
max_connections=50,
# Без этих таймаутов зависший Redis (или «чёрная дыра» вместо него)
# блокирует обработчик запроса до бесконечности.
socket_timeout=settings.redis_socket_timeout_seconds,
socket_connect_timeout=settings.redis_socket_connect_timeout_seconds,
# Не ретраить внутри клиента: лучше быстро вернуть 503, чем копить
# задержку повторов и выходить за дедлайн запроса.
retry_on_timeout=False,
health_check_interval=30,
)
async def get_redis() -> AsyncGenerator[aioredis.Redis, None]:
yield redis_client
+28
View File
@@ -0,0 +1,28 @@
import secrets
from passlib.context import CryptContext
_pwd_context = CryptContext(
schemes=["argon2"],
deprecated="auto",
argon2__time_cost=2,
argon2__memory_cost=65536, # 64 MiB
argon2__parallelism=2,
argon2__type="ID", # Argon2id
)
def hash_password(password: str) -> str:
return _pwd_context.hash(password)
def verify_password(password: str, password_hash: str) -> bool:
try:
return _pwd_context.verify(password, password_hash)
except ValueError:
return False
def generate_session_token() -> str:
# 32 байта = 256 бит энтропии, hex = 64 символа
return secrets.token_urlsafe(48)
View File
+6
View File
@@ -0,0 +1,6 @@
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
"""Общий базовый класс для всех ORM-моделей."""
pass
+49
View File
@@ -0,0 +1,49 @@
from collections.abc import AsyncGenerator
from sqlalchemy.ext.asyncio import (
AsyncSession,
async_sessionmaker,
create_async_engine,
)
from src.core.config import settings
engine = create_async_engine(
settings.database_url,
echo=False,
pool_size=10,
max_overflow=20,
pool_pre_ping=True,
pool_recycle=1800,
# Ограниченное ожидание свободного соединения в пуле.
pool_timeout=settings.db_pool_timeout_seconds,
connect_args={
# Таймаут установки TCP-соединения с PostgreSQL (asyncpg.timeout).
"timeout": settings.db_connect_timeout_seconds,
# Таймаут выполнения одной команды (asyncpg.command_timeout).
"command_timeout": settings.db_command_timeout_seconds,
# Серверный statement_timeout как страховка от «зависшего» запроса.
"server_settings": {
"statement_timeout": str(
int(settings.db_command_timeout_seconds * 1000)
),
"application_name": "mtusi-messenger-api",
},
},
)
async_session_factory = async_sessionmaker(
engine,
class_=AsyncSession,
expire_on_commit=False,
autoflush=False,
)
async def get_db() -> AsyncGenerator[AsyncSession, None]:
async with async_session_factory() as session:
try:
yield session
except Exception:
await session.rollback()
raise
+127
View File
@@ -0,0 +1,127 @@
import uuid
import redis.exceptions as redis_exceptions
from fastapi import FastAPI, HTTPException, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from sqlalchemy.exc import InterfaceError, OperationalError
from sqlalchemy.exc import TimeoutError as SATimeoutError
from src.api import auth, chats, health, messages, users
from src.core.middleware import RequestIdMiddleware
app = FastAPI(
title="MTUSI Messenger — lab2",
version="1.2.0",
)
app.add_middleware(RequestIdMiddleware)
app.include_router(health.router)
app.include_router(users.router)
app.include_router(auth.router)
app.include_router(chats.router)
app.include_router(messages.router)
def _rid(request: Request) -> str:
return getattr(request.state, "request_id", None) or str(uuid.uuid4())
def _code_for(status_code: int) -> str:
return {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
503: "unavailable",
500: "internal_error",
}.get(status_code, "internal_error")
@app.exception_handler(HTTPException)
async def http_exception_with_request_id(request: Request, exc: HTTPException):
rid = _rid(request)
response = JSONResponse(
status_code=exc.status_code,
content={
"error": {
"code": _code_for(exc.status_code),
"message": exc.detail if isinstance(exc.detail, str) else "error",
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
if exc.status_code == 401:
response.headers["WWW-Authenticate"] = 'Bearer realm="messenger"'
if exc.headers:
for k, v in exc.headers.items():
response.headers.setdefault(k, v)
return response
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
rid = _rid(request)
return JSONResponse(
status_code=400,
content={
"error": {
"code": "invalid_request",
"message": "invalid request",
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
async def dependency_unavailable_handler(request: Request, exc: Exception):
"""Недоступная зависимость — это 503, а не 500 и не «нет ответа».
Сюда попадают обрывы соединения с PostgreSQL (OperationalError,
InterfaceError), исчерпание пула (sqlalchemy TimeoutError) и ошибки
клиента Redis. Внутренние детали (DSN, SQL, стек) в ответ не попадают.
"""
rid = _rid(request)
return JSONResponse(
status_code=503,
content={
"error": {
"code": "unavailable",
"message": "dependency unavailable",
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
for _dependency_error in (
OperationalError,
InterfaceError,
SATimeoutError,
redis_exceptions.RedisError,
):
app.add_exception_handler(_dependency_error, dependency_unavailable_handler)
@app.exception_handler(Exception)
async def unhandled_exception_handler(request: Request, exc):
rid = _rid(request)
return JSONResponse(
status_code=500,
content={
"error": {
"code": "internal_error",
"message": "internal error",
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
View File
+110
View File
@@ -0,0 +1,110 @@
import uuid
from datetime import datetime
from sqlalchemy import (
CheckConstraint,
DateTime,
ForeignKey,
Index,
String,
Text,
func,
)
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.orm import Mapped, mapped_column, relationship
from src.db.base import Base
class User(Base):
__tablename__ = "users"
id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
)
username: Mapped[str] = mapped_column(
String(32), unique=True, nullable=False, index=True
)
display_name: Mapped[str] = mapped_column(String(100), nullable=False)
password_hash: Mapped[str] = mapped_column(Text, nullable=False)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), server_default=func.now(), nullable=False
)
__table_args__ = (
CheckConstraint(
"username ~ '^[a-z0-9_]{3,32}$'",
name="ck_users_username_format",
),
)
class Chat(Base):
__tablename__ = "chats"
id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
)
title: Mapped[str] = mapped_column(String(100), nullable=False)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), server_default=func.now(), nullable=False
)
members: Mapped[list["ChatMember"]] = relationship(
back_populates="chat", cascade="all, delete-orphan"
)
class ChatMember(Base):
__tablename__ = "chat_members"
chat_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("chats.id", ondelete="CASCADE"),
primary_key=True,
)
user_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("users.id", ondelete="CASCADE"),
primary_key=True,
)
chat: Mapped["Chat"] = relationship(back_populates="members")
class Message(Base):
__tablename__ = "messages"
id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
)
chat_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("chats.id", ondelete="CASCADE"),
nullable=False,
)
sender_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("users.id", ondelete="CASCADE"),
nullable=False,
)
text: Mapped[str] = mapped_column(Text, nullable=False)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), server_default=func.now(), nullable=False
)
__table_args__ = (
# Ключевой индекс для пагинации истории (оценка 4).
Index(
"idx_messages_chat_created_id",
"chat_id",
"created_at",
"id",
),
# Дополнительный индекс для сравнения планов запросов (трек 5).
Index(
"idx_messages_chat_id_created_at",
"chat_id",
"created_at",
),
)
View File
+105
View File
@@ -0,0 +1,105 @@
import uuid
from datetime import datetime
from pydantic import BaseModel, ConfigDict, Field
# ---------- Health ----------
class HealthResponse(BaseModel):
status: str = "ok"
# ---------- Errors ----------
class ErrorBody(BaseModel):
code: str
message: str
request_id: str
class ErrorResponse(BaseModel):
error: ErrorBody
# ---------- Users ----------
USERNAME_PATTERN = r"^[a-z0-9_]{3,32}$"
class CreateUserRequest(BaseModel):
model_config = ConfigDict(extra="forbid", str_strip_whitespace=True)
username: str = Field(pattern=USERNAME_PATTERN)
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
class UserResponse(BaseModel):
model_config = ConfigDict(from_attributes=True, extra="forbid")
id: uuid.UUID
username: str
display_name: str
created_at: datetime
# ---------- Sessions ----------
class SessionResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
token: str
token_type: str = "Bearer"
expires_at: datetime
user: UserResponse
# ---------- Chats ----------
class CreateChatRequest(BaseModel):
model_config = ConfigDict(extra="forbid", str_strip_whitespace=True)
title: str = Field(min_length=1, max_length=100)
member_ids: list[uuid.UUID] = Field(min_length=1, max_length=100)
class ChatResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
id: uuid.UUID
title: str
member_ids: list[uuid.UUID]
created_at: datetime
class ChatPage(BaseModel):
model_config = ConfigDict(extra="forbid")
items: list[ChatResponse]
next_cursor: str | None
# ---------- Messages ----------
class CreateMessageRequest(BaseModel):
model_config = ConfigDict(extra="forbid", str_strip_whitespace=True)
text: str = Field(min_length=1, max_length=4000)
class MessageResponse(BaseModel):
model_config = ConfigDict(from_attributes=True, extra="forbid")
id: uuid.UUID
chat_id: uuid.UUID
sender_id: uuid.UUID
text: str
created_at: datetime
class MessagePage(BaseModel):
model_config = ConfigDict(extra="forbid")
items: list[MessageResponse]
next_cursor: str | None
View File
+124
View File
@@ -0,0 +1,124 @@
import base64
import uuid
from datetime import datetime
from sqlalchemy import select, tuple_
from sqlalchemy.ext.asyncio import AsyncSession
from src.models.models import Chat, ChatMember, Message
class UnknownMemberError(Exception):
"""Хотя бы один member_id не существует в users."""
class CallerNotInMembersError(Exception):
"""Вызывающий не входит в member_ids."""
class ChatNotFoundError(Exception):
"""Чат не существует или недоступен."""
async def create_chat(
db: AsyncSession,
title: str,
member_ids: list[uuid.UUID],
caller_id: uuid.UUID,
) -> Chat:
unique_ids = set(member_ids)
if caller_id not in unique_ids:
raise CallerNotInMembersError()
# Проверяем, что все users существуют
from src.models.models import User
result = await db.execute(select(User.id).where(User.id.in_(unique_ids)))
existing = {row[0] for row in result.all()}
missing = unique_ids - existing
if missing:
raise UnknownMemberError()
chat = Chat(title=title)
db.add(chat)
await db.flush() # получаем chat.id
for uid in unique_ids:
db.add(ChatMember(chat_id=chat.id, user_id=uid))
await db.commit()
await db.refresh(chat)
return chat
async def get_chat_for_user(
db: AsyncSession,
chat_id: uuid.UUID,
user_id: uuid.UUID,
) -> Chat | None:
stmt = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
)
result = await db.execute(stmt)
return result.scalar_one_or_none()
async def get_member_ids(
db: AsyncSession,
chat_id: uuid.UUID,
) -> list[uuid.UUID]:
stmt = select(ChatMember.user_id).where(ChatMember.chat_id == chat_id)
result = await db.execute(stmt)
return [row[0] for row in result.all()]
# ---------- Пагинация списка чатов ----------
def encode_cursor(created_at: datetime, chat_id: uuid.UUID) -> str:
raw = f"{created_at.isoformat()}|{chat_id}"
return base64.urlsafe_b64encode(raw.encode()).decode()
def decode_cursor(cursor: str) -> tuple[datetime, uuid.UUID]:
try:
raw = base64.urlsafe_b64decode(cursor.encode()).decode()
ts_str, id_str = raw.split("|", 1)
return datetime.fromisoformat(ts_str), uuid.UUID(id_str)
except (ValueError, UnicodeDecodeError) as exc:
raise ValueError("invalid cursor") from exc
async def list_chats_for_user(
db: AsyncSession,
user_id: uuid.UUID,
limit: int,
cursor: str | None,
) -> tuple[list[Chat], str | None]:
stmt = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(ChatMember.user_id == user_id)
.order_by(Chat.created_at.asc(), Chat.id.asc())
.limit(limit + 1)
)
if cursor:
cursor_ts, cursor_id = decode_cursor(cursor)
# Та же семантика keyset-пагинации, что и для истории сообщений:
# граница диапазона по (created_at, id), а не фильтр поверх
# полного результата.
stmt = stmt.where(
tuple_(Chat.created_at, Chat.id) > (cursor_ts, cursor_id)
)
result = await db.execute(stmt)
rows = list(result.scalars().all())
next_cursor: str | None = None
if len(rows) > limit:
last = rows[limit - 1]
next_cursor = encode_cursor(last.created_at, last.id)
rows = rows[:limit]
return rows, next_cursor
+75
View File
@@ -0,0 +1,75 @@
import base64
import uuid
from datetime import datetime
from sqlalchemy import select, tuple_
from sqlalchemy.ext.asyncio import AsyncSession
from src.models.models import Message
def encode_cursor(created_at: datetime, message_id: uuid.UUID) -> str:
raw = f"{created_at.isoformat()}|{message_id}"
return base64.urlsafe_b64encode(raw.encode()).decode()
def decode_cursor(cursor: str) -> tuple[datetime, uuid.UUID]:
try:
raw = base64.urlsafe_b64decode(cursor.encode()).decode()
ts_str, id_str = raw.split("|", 1)
return datetime.fromisoformat(ts_str), uuid.UUID(id_str)
except (ValueError, UnicodeDecodeError) as exc:
raise ValueError("invalid cursor") from exc
async def create_message(
db: AsyncSession,
chat_id: uuid.UUID,
sender_id: uuid.UUID,
text: str,
) -> Message:
message = Message(
chat_id=chat_id,
sender_id=sender_id,
text=text,
)
db.add(message)
await db.commit()
await db.refresh(message)
return message
async def list_messages(
db: AsyncSession,
chat_id: uuid.UUID,
limit: int,
cursor: str | None,
) -> tuple[list[Message], str | None]:
stmt = (
select(Message)
.where(Message.chat_id == chat_id)
.order_by(Message.created_at.asc(), Message.id.asc())
.limit(limit + 1)
)
if cursor:
cursor_ts, cursor_id = decode_cursor(cursor)
# Row-comparison, а не OR из двух условий. PostgreSQL умеет
# использовать ROW(created_at, id) > ROW(:ts, :id) как границу
# диапазона составного индекса idx_messages_chat_created_id:
# читаются только нужные строки (Index Cond), без чтения и
# отбрасывания всей предыдущей истории через Filter.
stmt = stmt.where(
tuple_(Message.created_at, Message.id) > (cursor_ts, cursor_id)
)
result = await db.execute(stmt)
rows = list(result.scalars().all())
next_cursor: str | None = None
if len(rows) > limit:
last = rows[limit - 1]
next_cursor = encode_cursor(last.created_at, last.id)
rows = rows[:limit]
return rows, next_cursor
+50
View File
@@ -0,0 +1,50 @@
import uuid
import redis.asyncio as aioredis
from src.core.config import settings
from src.core.security import generate_session_token
KEY_PREFIX = "session:"
def _key(token: str) -> str:
return KEY_PREFIX + token
async def create_session(
redis: aioredis.Redis,
user_id: uuid.UUID,
ttl_seconds: int | None = None,
) -> str:
token = generate_session_token()
ttl = ttl_seconds if ttl_seconds is not None else settings.session_ttl_seconds
await redis.set(_key(token), str(user_id), ex=ttl)
return token
async def get_session_user_id(
redis: aioredis.Redis,
token: str,
) -> uuid.UUID | None:
value = await redis.get(_key(token))
if value is None:
return None
try:
return uuid.UUID(value)
except ValueError:
return None
async def revoke_session(redis: aioredis.Redis, token: str) -> None:
await redis.delete(_key(token))
async def touch_session(
redis: aioredis.Redis,
token: str,
ttl_seconds: int | None = None,
) -> None:
"""Продлить TTL сессии (опционально)."""
ttl = ttl_seconds if ttl_seconds is not None else settings.session_ttl_seconds
await redis.expire(_key(token), ttl)
+51
View File
@@ -0,0 +1,51 @@
import uuid
from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
from src.core.security import hash_password
from src.models.models import User
class UsernameTakenError(Exception):
"""Username уже занят."""
async def create_user(
db: AsyncSession,
username: str,
display_name: str,
password: str,
) -> User:
user = User(
username=username,
display_name=display_name,
password_hash=hash_password(password),
)
db.add(user)
try:
await db.commit()
except IntegrityError as exc:
await db.rollback()
raise UsernameTakenError(username) from exc
await db.refresh(user)
return user
async def get_user_by_username(
db: AsyncSession,
username: str,
) -> User | None:
stmt = select(User).where(User.username == username)
result = await db.execute(stmt)
return result.scalar_one_or_none()
async def get_user_by_id(
db: AsyncSession,
user_id: uuid.UUID,
) -> User | None:
stmt = select(User).where(User.id == user_id)
result = await db.execute(stmt)
return result.scalar_one_or_none()
+155
View File
@@ -0,0 +1,155 @@
"""Общие помощники для тестов отказов.
Скрипты запускаются из корня репозитория:
python student-tests/test_postgres_down.py
python student-tests/test_redis_down.py
Имена контейнеров не хардкодятся: они берутся из `docker compose ps -q`,
поэтому тест переживает смену имени каталога/проекта Compose.
"""
import json
import os
import subprocess
import time
import urllib.error
import urllib.request
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
# 127.0.0.1 вместо localhost: на Windows localhost может резолвиться в IPv6 и
# добавлять секунды к каждому запросу, что исказило бы замеры бюджета.
BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/")
# Бюджет наблюдаемого ответа: API обязан уложиться заметно ниже 6 секунд.
RESPONSE_BUDGET_SECONDS = float(os.environ.get("RESPONSE_BUDGET_SECONDS", "6.0"))
def compose(*args, check=True):
command = [
"docker",
"compose",
"--env-file",
".env",
*args,
]
completed = subprocess.run(
command,
cwd=ROOT,
capture_output=True,
text=True,
)
if check and completed.returncode != 0:
raise RuntimeError(
"docker compose %s failed: %s"
% (" ".join(args), (completed.stderr or completed.stdout).strip())
)
return completed
def container_id(service):
completed = compose("ps", "-q", service)
identifier = completed.stdout.strip()
if not identifier:
raise RuntimeError(
"service %r is not running; start the stack with "
"`docker compose --env-file .env up -d`" % service
)
return identifier
def container_health(identifier):
completed = subprocess.run(
[
"docker",
"inspect",
"--format={{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}",
identifier,
],
capture_output=True,
text=True,
)
return completed.stdout.strip()
def stop_service(service):
compose("stop", service)
def start_service(service):
compose("start", service)
def wait_healthy(identifier, timeout_seconds=60):
deadline = time.monotonic() + timeout_seconds
while time.monotonic() < deadline:
if container_health(identifier) == "healthy":
return
time.sleep(0.5)
raise RuntimeError("container %s did not become healthy" % identifier)
def call(method, path, body=None, headers=None, timeout=20):
"""Возвращает (status, payload, elapsed_seconds)."""
request_headers = {"Accept": "application/json"}
request_headers.update(headers or {})
data = None
if body is not None:
data = json.dumps(body).encode()
request_headers["Content-Type"] = "application/json"
request = urllib.request.Request(
BASE_URL + path,
data=data,
headers=request_headers,
method=method,
)
started = time.monotonic()
try:
with urllib.request.urlopen(request, timeout=timeout) as response:
raw = response.read().decode() or "{}"
status = response.status
except urllib.error.HTTPError as error:
raw = error.read().decode() or "{}"
status = error.code
elapsed = time.monotonic() - started
try:
payload = json.loads(raw)
except ValueError:
payload = {"raw": raw}
return status, payload, elapsed
def wait_ready(timeout_seconds=60):
deadline = time.monotonic() + timeout_seconds
last = None
while time.monotonic() < deadline:
try:
status, payload, _ = call("GET", "/health/ready", timeout=5)
last = (status, payload)
if status == 200:
return
except (urllib.error.URLError, OSError) as error:
last = error
time.sleep(0.5)
raise RuntimeError("API did not become ready; last result: %r" % (last,))
def assert_within_budget(elapsed, label):
if elapsed >= RESPONSE_BUDGET_SECONDS:
raise AssertionError(
"%s took %.2fs, budget is %.1fs"
% (label, elapsed, RESPONSE_BUDGET_SECONDS)
)
def assert_error_payload(payload, expected_code):
error = payload.get("error")
if not isinstance(error, dict):
raise AssertionError("response has no error object: %r" % (payload,))
if error.get("code") != expected_code:
raise AssertionError(
"expected error code %r, got %r" % (expected_code, error.get("code"))
)
if not error.get("request_id"):
raise AssertionError("error payload has no request_id")
if not error.get("message"):
raise AssertionError("error payload has no message")
+155
View File
@@ -0,0 +1,155 @@
"""Трек 5, вариант 2: план запроса и восстановление.
Сравнивает два индекса сообщений:
* idx_messages_chat_created_id (chat_id, created_at, id) — row‑comparison курсор
* idx_messages_chat_id_created_at (chat_id, created_at) — простой диапазон по created_at
Измеряет план (EXPLAIN ANALYZE + BUFFERS), время вставки и выполняет
backup/restore через pg_dump/pg_restore.
Запуск (стек должен быть поднят):
python student-tests/experiment_query_restore.py
"""
import base64
import os
import subprocess
import time
from datetime import datetime
from _harness import BASE_URL, call
EVIDENCE = os.path.join(os.path.dirname(__file__), "..", "evidence")
os.makedirs(EVIDENCE, exist_ok=True)
OUTFILE = os.path.join(EVIDENCE, "experiment_query_restore.txt")
HEADER = "=" * 70
lines = []
def log(text):
lines.append(text)
print(text)
def psql(sql, tuples=False):
cmd = [
"docker", "compose", "exec", "-T", "postgres", "psql",
"-U", "messenger", "-d", "messenger",
]
if tuples:
cmd += ["-tA"]
cmd += ["-c", sql]
result = subprocess.run(cmd, capture_output=True, text=True)
if result.returncode != 0:
raise RuntimeError(f"psql error: {result.stderr[:500]}")
return result.stdout
def register_user_and_chat():
status, payload, _ = call("POST", "/api/v1/users", body={
"username": "exp_restore_user",
"display_name": "EXP_RESTORE",
"password": "ExpRestorePass123!",
})
if status == 201:
uid = payload["id"]
else:
cred = base64.b64encode(b"exp_restore_user:ExpRestorePass123!").decode()
status, payload, _ = call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred})
uid = payload["user"]["id"]
cred = base64.b64encode(b"exp_restore_user:ExpRestorePass123!").decode()
status, payload, _ = call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred})
token = payload["token"]
auth = {"Authorization": "Bearer " + token}
status, payload, _ = call("POST", "/api/v1/chats", body={"title": "exp_restore_chat", "member_ids": [uid]}, headers=auth)
assert status == 201, f"chat creation failed: {status} {payload}"
return uid, payload["id"], auth
def bulk_insert_messages(chat_id, user_id, count, offset=0):
sql = f"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
'{chat_id}'::uuid,
'{user_id}'::uuid,
'exp-' || g,
now() - (g || ' seconds')::interval - ('{offset}' || ' seconds')::interval
FROM generate_series({offset + 1}, {offset + count}) AS g;
"""
start = time.monotonic()
out = psql(sql)
elapsed = time.monotonic() - start
log(f"Bulk insert of {count} messages took {elapsed:.3f}s (last stdout: {out.strip()[:80]})")
return elapsed
def explain(chat_id, cursor_ts, cursor_id, index_name=None):
if index_name == "idx_messages_chat_created_id":
where = f"AND (created_at, id) > ('{cursor_ts}'::timestamptz, '{cursor_id}'::uuid)"
else:
where = f"AND created_at > '{cursor_ts}'::timestamptz"
plan = f"""
EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)
SELECT id FROM messages
WHERE chat_id = '{chat_id}'::uuid {where}
ORDER BY created_at ASC, id ASC
LIMIT 51
"""
return psql(plan)
def backup_restore():
log(HEADER)
log("Backup via pg_dump (custom format) and restore into a fresh DB")
log(HEADER)
dump_path = "/tmp/messenger_exp_backup.dump"
subprocess.run(["docker", "compose", "exec", "-T", "postgres", "pg_dump", "-Fc", "-f", dump_path, "messenger"], check=True)
log(f"pg_dump created at {dump_path}")
subprocess.run(["docker", "compose", "exec", "-T", "postgres", "createdb", "-U", "messenger", "messenger_restore"], check=False)
subprocess.run(["docker", "compose", "exec", "-T", "postgres", "pg_restore", "-d", "messenger_restore", dump_path], check=True)
cnt1 = psql("SELECT count(*) FROM messages", tuples=True).strip()
cnt2 = psql("SELECT count(*) FROM messenger_restore.messages", tuples=True).strip()
log(f"messages before restore: {cnt1}, after restore: {cnt2}")
sample = psql("SELECT id, chat_id, sender_id, text, created_at FROM messages ORDER BY created_at DESC LIMIT 1", tuples=True)
log(f"sample before restore: {sample.strip()}")
sample2 = psql("SELECT id, chat_id, sender_id, text, created_at FROM messenger_restore.messages ORDER BY created_at DESC LIMIT 1", tuples=True)
log(f"sample after restore: {sample2.strip()}")
def main():
log(HEADER)
log("Experiment: query plan and restore (track 5, option 2)")
log(HEADER)
uid, chat_id, auth = register_user_and_chat()
bulk_insert_messages(chat_id, uid, 90000)
status, payload, _ = call("POST", "/api/v1/chats", body={"title": "exp_restore_chat2", "member_ids": [uid]}, headers=auth)
chat2_id = payload["id"]
bulk_insert_messages(chat2_id, uid, 10000)
cursor_row = psql(f"""
SELECT id::text, created_at::text FROM messages
WHERE chat_id = '{chat_id}'::uuid
ORDER BY created_at ASC, id ASC
LIMIT 1 OFFSET 99950
""", tuples=True).strip()
cursor_id, cursor_ts_raw = cursor_row.split("|")
cursor_ts = datetime.fromisoformat(cursor_ts_raw).isoformat()
log("EXPLAIN ANALYZE for idx_messages_chat_created_id")
plan_a = explain(chat_id, cursor_ts, cursor_id, index_name="idx_messages_chat_created_id")
log(plan_a)
log("EXPLAIN ANALYZE for idx_messages_chat_id_created_at")
plan_b = explain(chat_id, cursor_ts, cursor_id, index_name="idx_messages_chat_id_created_at")
log(plan_b)
backup_restore()
with open(OUTFILE, "w", encoding="utf-8") as f:
f.write("\n".join(lines))
log(f"\nResults written to {OUTFILE}")
if __name__ == "__main__":
main()
+173
View File
@@ -0,0 +1,173 @@
"""EXPLAIN ANALYZE до/после на 10 000+ сообщений.
Сравнивает план OR-курсорa (было) и row-comparison (стало).
Результаты сохраняются в evidence/explain_pagination.txt.
Запуск (стек поднят):
python student-tests/explain_pagination.py
"""
import base64
import os
import subprocess
import sys
import time
from datetime import datetime
sys.path.insert(0, os.path.dirname(__file__))
from _harness import BASE_URL, call
EVIDENCE = os.path.join(os.path.dirname(__file__), "..", "evidence")
os.makedirs(EVIDENCE, exist_ok=True)
OUTFILE = os.path.join(EVIDENCE, "explain_pagination.txt")
HEADER = "=" * 70
lines = []
def log(text):
lines.append(text)
print(text)
def psql(sql, tuples=False):
"""Run SQL via docker compose exec psql. Return stdout.
tuples=True — режим `-tA` (без заголовков/выравнивания), удобен для
разбора значений в Python. Для EXPLAIN оставляем обычный вывод.
"""
cmd = [
"docker", "compose", "exec", "-T", "postgres", "psql",
"-U", "messenger", "-d", "messenger",
]
if tuples:
cmd += ["-tA"]
cmd += ["-c", sql]
result = subprocess.run(cmd, capture_output=True, text=True)
if result.returncode != 0:
raise RuntimeError(f"psql error: {result.stderr[:500]}")
return result.stdout
# ---- Step 1: user + session + chat ------------------------------------------
log(HEADER)
log("Step 1: register user and create chat")
log(HEADER)
status, payload, _ = call("POST", "/api/v1/users", body={
"username": "explain_user",
"display_name": "EXPLAIN",
"password": "ExplPass123!",
})
if status == 201:
uid = payload["id"]
log("Registered new user")
else:
cred = base64.b64encode(b"explain_user:ExplPass123!").decode()
status, payload, _ = call("POST", "/api/v1/auth/sessions",
headers={"Authorization": "Basic " + cred})
uid = payload["user"]["id"]
log(f"User already exists, uid = {uid}")
cred = base64.b64encode(b"explain_user:ExplPass123!").decode()
status, payload, _ = call("POST", "/api/v1/auth/sessions",
headers={"Authorization": "Basic " + cred})
token = payload["token"]
auth = {"Authorization": "Bearer " + token}
status, payload, _ = call("POST", "/api/v1/chats",
body={"title": "explain_test", "member_ids": [uid]},
headers=auth)
assert status == 201, f"chat creation failed: {status} {payload}"
chat_id = payload["id"]
log(f"chat_id = {chat_id}")
# ---- Step 2: bulk-insert 10 000 messages ------------------------------------
log(HEADER)
log("Step 2: bulk-insert 10 000 messages via psql")
log(HEADER)
psql(f"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
'{chat_id}'::uuid,
'{uid}'::uuid,
'msg-' || generate_series(1, 10000),
now() - (generate_series(1, 10000) || ' seconds')::interval
""")
out = psql(f"SELECT count(*) FROM messages WHERE chat_id = '{chat_id}'::uuid", tuples=True)
log(f"Message count: {out.strip()}")
# ---- Step 3: cursor boundary (row 9950) ------------------------------------
log(HEADER)
log("Step 3: cursor boundary at row 9950 (late page)")
log(HEADER)
row = psql(f"""
SELECT id::text, created_at::text FROM messages
WHERE chat_id = '{chat_id}'::uuid
ORDER BY created_at ASC, id ASC
LIMIT 1 OFFSET 9950
""", tuples=True).strip()
parts = row.split("|")
cursor_id = parts[0].strip()
cursor_ts_raw = parts[1].strip()
cursor_dt = datetime.fromisoformat(cursor_ts_raw)
cursor_ts = cursor_dt.isoformat()
log(f"cursor_id = {cursor_id}")
log(f"cursor_ts = {cursor_ts}")
# ---- Step 4: EXPLAIN ANALYZE — OLD (OR form) --------------------------------
log(HEADER)
log("Step 4: EXPLAIN ANALYZE — OLD form (OR cursor)")
log(HEADER)
old_sql = f"""
EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '{chat_id}'::uuid
AND (created_at > '{cursor_ts}'::timestamptz
OR (created_at = '{cursor_ts}'::timestamptz
AND id > '{cursor_id}'::uuid))
ORDER BY created_at ASC, id ASC
LIMIT 51
"""
log(psql(old_sql))
# ---- Step 5: EXPLAIN ANALYZE — NEW (row-comparison) -------------------------
log(HEADER)
log("Step 5: EXPLAIN ANALYZE — NEW form (row-comparison / Index Cond)")
log(HEADER)
new_sql = f"""
EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '{chat_id}'::uuid
AND (created_at, id) > ('{cursor_ts}'::timestamptz, '{cursor_id}'::uuid)
ORDER BY created_at ASC, id ASC
LIMIT 51
"""
log(psql(new_sql))
# ---- Step 6: HTTP timing ----------------------------------------------------
log(HEADER)
log("Step 6: HTTP timing — late page via API")
log(HEADER)
cursor_value = f"{cursor_ts}|{cursor_id}"
cursor_encoded = base64.urlsafe_b64encode(cursor_value.encode()).decode()
log(f"API cursor (base64url): {cursor_encoded[:40]}...")
status, payload, elapsed = call(
"GET",
f"/api/v1/chats/{chat_id}/messages?limit=100&cursor={cursor_encoded}",
headers=auth,
)
log(f"API response: {status} in {elapsed:.4f}s, {len(payload.get('items', []))} items")
# ---- Write output -----------------------------------------------------------
with open(OUTFILE, "w", encoding="utf-8") as f:
f.write("\n".join(lines))
log(f"\nResults written to {OUTFILE}")
+156
View File
@@ -0,0 +1,156 @@
"""Автотест отказа PostgreSQL.
Проверяет, что при остановленной базе API:
* отвечает за ограниченное время (не «висит»);
* отдаёт 503 в общем формате ошибки, а не 500 и не пустое соединение;
* /health/live остаётся 200 (процесс жив), /health/ready — 503;
* анонимный запрос по-прежнему получает 401 (аутентификация до БД);
* после возврата базы восстанавливается: readiness 200, прежний Bearer-токен
работает, подтверждённое до отказа сообщение читается.
Запуск (стек должен быть поднят):
python student-tests/test_postgres_down.py
"""
import base64
import uuid
from _harness import (
assert_error_payload,
assert_within_budget,
call,
container_id,
start_service,
stop_service,
wait_healthy,
wait_ready,
)
def register_and_login(username, password):
status, payload, _ = call(
"POST",
"/api/v1/users",
body={
"username": username,
"display_name": "Postgres Down Test",
"password": password,
},
)
assert status == 201, "register failed: %s %s" % (status, payload)
credential = base64.b64encode(
("%s:%s" % (username, password)).encode()
).decode()
status, payload, _ = call(
"POST",
"/api/v1/auth/sessions",
headers={"Authorization": "Basic " + credential},
)
assert status == 201, "login failed: %s %s" % (status, payload)
return payload["token"]
def main():
postgres = container_id("postgres")
wait_healthy(postgres)
wait_ready()
suffix = uuid.uuid4().hex[:8]
token = register_and_login("pgdown_" + suffix, "PgDownPass123")
auth = {"Authorization": "Bearer " + token}
status, user, _ = call("GET", "/api/v1/users/me", headers=auth)
assert status == 200, "token must work before the outage: %s %s" % (status, user)
status, chat, _ = call(
"POST",
"/api/v1/chats",
body={"title": "Postgres outage", "member_ids": [user["id"]]},
headers=auth,
)
assert status == 201, "chat creation failed: %s %s" % (status, chat)
status, message, _ = call(
"POST",
"/api/v1/chats/%s/messages" % chat["id"],
body={"text": "подтверждено до отказа"},
headers=auth,
)
assert status == 201, "message creation failed: %s %s" % (status, message)
print("Setup: user, chat and message created")
try:
stop_service("postgres")
print("PostgreSQL stopped")
status, payload, elapsed = call("GET", "/health/ready")
assert_within_budget(elapsed, "readiness with PostgreSQL down")
assert status == 503, "readiness must be 503, got %s %s" % (status, payload)
assert_error_payload(payload, "unavailable")
print("readiness: 503 in %.2fs (budget %.0fs)" % (elapsed, 6.0))
status, payload, elapsed = call("GET", "/health/live")
assert status == 200, "liveness must stay 200, got %s" % status
print("liveness: 200")
status, payload, elapsed = call(
"GET", "/api/v1/users/me", headers=auth
)
assert_within_budget(elapsed, "authenticated request with PostgreSQL down")
assert status == 503, (
"authenticated request must be 503, got %s %s" % (status, payload)
)
assert_error_payload(payload, "unavailable")
print("authenticated request: 503 in %.2fs" % elapsed)
status, payload, elapsed = call("GET", "/api/v1/users/me")
assert status == 401, (
"anonymous request must stay 401, got %s %s" % (status, payload)
)
assert_within_budget(elapsed, "anonymous request with PostgreSQL down")
print("anonymous request: 401 (no trust granted without token)")
status, payload, elapsed = call(
"POST",
"/api/v1/chats/%s/messages" % chat["id"],
body={"text": "во время отказа"},
headers=auth,
)
assert status == 503, (
"write during outage must be 503, got %s %s" % (status, payload)
)
assert_within_budget(elapsed, "write with PostgreSQL down")
print("write during outage: 503 in %.2fs, message not acknowledged" % elapsed)
finally:
start_service("postgres")
wait_healthy(postgres)
print("PostgreSQL restarted")
wait_ready()
print("readiness after recovery: 200")
status, payload, _ = call("GET", "/api/v1/users/me", headers=auth)
assert status == 200, (
"existing token must work after recovery, got %s %s" % (status, payload)
)
print("existing token after recovery: 200")
status, page, _ = call(
"GET", "/api/v1/chats/%s/messages?limit=100" % chat["id"], headers=auth
)
assert status == 200, "history read failed after recovery: %s" % status
identifiers = [item["id"] for item in page["items"]]
assert message["id"] in identifiers, "confirmed message disappeared after outage"
assert len(identifiers) == len(set(identifiers)), "history contains duplicates"
assert "во время отказа" not in [item["text"] for item in page["items"]], (
"unacknowledged message must not appear in history"
)
print("confirmed message preserved, unacknowledged write absent")
print("PASS: PostgreSQL outage handled with bounded 503 and full recovery")
if __name__ == "__main__":
main()
+56
View File
@@ -0,0 +1,56 @@
"""Test: concurrent registration of the same username must produce exactly one 201 and one 409."""
import base64
import json
import threading
import urllib.error
import urllib.request
import uuid
BASE = "http://localhost:8080"
def post_user(username: str, password: str):
body = json.dumps({
"username": username,
"display_name": "Race Test",
"password": password,
}).encode()
req = urllib.request.Request(
BASE + "/api/v1/users",
data=body,
headers={"Content-Type": "application/json"},
method="POST",
)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
return resp.status, resp.read().decode()
except urllib.error.HTTPError as e:
return e.code, e.read().decode()
def main():
username = "race_" + uuid.uuid4().hex[:8]
password = "RaceTestPassword123"
results = []
lock = threading.Lock()
def worker():
status, body = post_user(username, password)
with lock:
results.append((status, body))
threads = [threading.Thread(target=worker) for _ in range(2)]
for t in threads:
t.start()
for t in threads:
t.join()
statuses = [s for s, _ in results]
print("Statuses:", statuses)
assert sorted(statuses) == [201, 409], f"expected [201, 409], got {statuses}"
print("PASS: race registration — one 201, one 409")
if __name__ == "__main__":
main()
+167
View File
@@ -0,0 +1,167 @@
"""Автотест отказа Redis (хранилища сессий).
Зеркалит student-tests/test_postgres_down.py: проверяется тот же контракт
отказа, но деградирует Redis, а не PostgreSQL.
При остановленном Redis API:
* /health/live остаётся 200 (процесс жив), /health/ready — 503;
* анонимный запрос получает 401 (аутентификация не зависит от Redis);
* запрос с прежним токеном получает 503 в общем формате ошибки, а не 401
(«нет сессии») и не 500 — недоступность не превращается в отказ доступа;
* чтение и запись с токеном — 503 за ограниченное время;
* после возврата Redis readiness 200, прежний токен снова работает,
подтверждённые данные читаются, неподтверждённая запись отсутствует.
Запуск (стек должен быть поднят):
python student-tests/test_redis_down.py
"""
import base64
import uuid
from _harness import (
RESPONSE_BUDGET_SECONDS,
assert_error_payload,
assert_within_budget,
call,
container_id,
start_service,
stop_service,
wait_healthy,
wait_ready,
)
def register_and_login(username, password):
"""Создать пользователя, войти, вернуть (token, user_id)."""
status, payload, _ = call(
"POST",
"/api/v1/users",
body={
"username": username,
"display_name": "Redis Down Test",
"password": password,
},
)
assert status == 201, "register failed: %s %s" % (status, payload)
user_id = payload["id"]
credential = base64.b64encode(
("%s:%s" % (username, password)).encode()
).decode()
status, payload, _ = call(
"POST",
"/api/v1/auth/sessions",
headers={"Authorization": "Basic " + credential},
)
assert status == 201, "login failed: %s %s" % (status, payload)
return payload["token"], user_id
def main():
redis_container = container_id("redis")
wait_healthy(redis_container)
wait_ready()
suffix = uuid.uuid4().hex[:8]
token, user_id = register_and_login("redisdown_" + suffix, "RedisDownPass123")
auth = {"Authorization": "Bearer " + token}
status, me, _ = call("GET", "/api/v1/users/me", headers=auth)
assert status == 200, "token must work before the outage: %s %s" % (status, me)
status, chat, _ = call(
"POST",
"/api/v1/chats",
body={"title": "Redis outage", "member_ids": [user_id]},
headers=auth,
)
assert status == 201, "chat creation failed: %s %s" % (status, chat)
status, message, _ = call(
"POST",
"/api/v1/chats/%s/messages" % chat["id"],
body={"text": "подтверждено до отказа Redis"},
headers=auth,
)
assert status == 201, "message creation failed: %s %s" % (status, message)
print("Setup: user, session, chat and message created")
try:
stop_service("redis")
print("Redis stopped")
status, payload, elapsed = call("GET", "/health/ready")
assert_within_budget(elapsed, "readiness with Redis down")
assert status == 503, "readiness must be 503, got %s %s" % (status, payload)
assert_error_payload(payload, "unavailable")
print(
"readiness: 503 in %.2fs (budget %.0fs)"
% (elapsed, RESPONSE_BUDGET_SECONDS)
)
status, payload, elapsed = call("GET", "/health/live")
assert status == 200, "liveness must stay 200, got %s" % status
print("liveness: 200")
status, payload, elapsed = call("GET", "/api/v1/users/me")
assert status == 401, (
"anonymous request must stay 401, got %s %s" % (status, payload)
)
assert_within_budget(elapsed, "anonymous request with Redis down")
print("anonymous request: 401 (missing credentials, not a store failure)")
status, payload, elapsed = call("GET", "/api/v1/users/me", headers=auth)
assert_within_budget(elapsed, "authenticated request with Redis down")
assert status == 503, (
"authenticated request must be 503, got %s %s" % (status, payload)
)
assert_error_payload(payload, "unavailable")
print("authenticated request: 503 in %.2fs (not 401: session may exist)" % elapsed)
status, payload, elapsed = call(
"POST",
"/api/v1/chats/%s/messages" % chat["id"],
body={"text": "во время отказа Redis"},
headers=auth,
)
assert status == 503, (
"write during outage must be 503, got %s %s" % (status, payload)
)
assert_within_budget(elapsed, "write with Redis down")
print("write during outage: 503 in %.2fs, message not acknowledged" % elapsed)
finally:
start_service("redis")
wait_healthy(redis_container)
print("Redis restarted")
wait_ready()
print("readiness after recovery: 200")
status, payload, elapsed = call("GET", "/api/v1/users/me", headers=auth)
assert status == 200, (
"existing token must work after recovery, got %s %s" % (status, payload)
)
assert_within_budget(elapsed, "authenticated request after recovery")
print("existing token after recovery: 200 (session survived in AOF)")
status, page, elapsed = call(
"GET", "/api/v1/chats/%s/messages?limit=100" % chat["id"], headers=auth
)
assert status == 200, "history read failed after recovery: %s" % status
assert_within_budget(elapsed, "history read after recovery")
identifiers = [item["id"] for item in page["items"]]
assert message["id"] in identifiers, "confirmed message disappeared after outage"
assert len(identifiers) == len(set(identifiers)), "history contains duplicates"
texts = [item["text"] for item in page["items"]]
assert "во время отказа Redis" not in texts, (
"unacknowledged message must not appear in history"
)
print("confirmed message preserved, unacknowledged write absent")
print("PASS: Redis outage handled with bounded 503 and full recovery")
if __name__ == "__main__":
main()
+78
View File
@@ -0,0 +1,78 @@
"""Test: session expires after SESSION_TTL_SECONDS.
Тест требует короткого TTL: запустите стенд с SESSION_TTL_SECONDS=2
(например, временно изменив .env и выполнив `docker compose restart api`).
Запуск:
python student-tests/test_session_expiry.py
"""
import base64
import json
import os
import time
import urllib.error
import urllib.request
import uuid
BASE = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/")
EXPECTED_TTL = int(os.environ.get("EXPECTED_TTL_SECONDS", "2"))
def call(method, path, body=None, headers=None):
h = {"Accept": "application/json"}
h.update(headers or {})
data = None
if body is not None:
data = json.dumps(body).encode()
h["Content-Type"] = "application/json"
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
return resp.status, json.loads(resp.read().decode() or "{}")
except urllib.error.HTTPError as e:
return e.code, json.loads(e.read().decode() or "{}")
def main():
# 1. Регистрируем пользователя
username = "exp_" + uuid.uuid4().hex[:8]
password = "ExpiryTestPass123"
status, user = call("POST", "/api/v1/users", {
"username": username,
"display_name": "Expiry Test",
"password": password,
})
assert status == 201, f"register failed: {status} {user}"
# 2. Логинимся
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
status, session = call("POST", "/api/v1/auth/sessions", headers={
"Authorization": "Basic " + cred,
})
assert status == 201, f"login failed: {status} {session}"
token = session["token"]
print(f"Got token; waiting {EXPECTED_TTL + 2}s for expiry...")
# 3. Проверяем, что токен сразу работает
status, _ = call("GET", "/api/v1/users/me", headers={
"Authorization": "Bearer " + token,
})
assert status == 200, f"token should work immediately, got {status}"
print("Token works immediately: OK")
# 4. Ждём больше TTL
time.sleep(EXPECTED_TTL + 2)
# 5. Проверяем, что токен больше не работает
status, body = call("GET", "/api/v1/users/me", headers={
"Authorization": "Bearer " + token,
})
assert status == 401, f"expired token should give 401, got {status} {body}"
print("Token rejected after TTL: OK")
print("PASS: session expiry works")
if __name__ == "__main__":
main()