diff --git a/.env.example b/.env.example index d32b9be0..607fa6c2 100644 --- a/.env.example +++ b/.env.example @@ -1,13 +1,6 @@ # 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 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 -API_REPLICAS=2 -IDEMPOTENCY_TTL_SECONDS=86400 +POSTGRES_USER=messenger +POSTGRES_PASSWORD=replace-with-a-random-32-character-value +POSTGRES_DB=messenger diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..455c2251 --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/Makefile b/Makefile index 5d86d171..cbb9330d 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +.PHONY: help check validate test load test-persistence test-failover test-idempotency help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -28,3 +28,6 @@ test-persistence: test-failover: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2) $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +test-idempotency: + $(PYTHON) tests/concurrent_idempotency.py --base-url "$(BASE_URL)" $(TLS_ARGS) diff --git a/REPORT.md b/REPORT.md index c2679005..104b2f06 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,66 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Зюлина Екатерина Михайловна, БВТ2302. +- Целевая оценка: 3. +- Commit/PR: заполнить после публикации. +- Использованные источники и помощь: документация/контракт репозитория; собственная реализация lab2; помощь Codex при анализе требований и реализации. -## Запуск из чистого clone +## Запуск из чистого clone (Windows PowerShell + Docker Desktop Linux Engine) -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Требуются Docker Desktop с Linux containers, Docker Compose v2, Git и Python 3.11. Из PowerShell в корне clone: + +```powershell +Copy-Item .env.example .env +py -3.11 -c 'from pathlib import Path; import secrets; p=Path(".env"); p.write_text(p.read_text().replace("replace-with-a-random-32-character-value", secrets.token_hex(24)))' +$env:PYTHONUTF8 = '1' +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 +Invoke-WebRequest http://localhost:8080/health/ready -UseBasicParsing +.\.venv\Scripts\python.exe scripts\check_contract.py +.\.venv\Scripts\python.exe tests\smoke.py --base-url http://localhost:8080 +.\.venv\Scripts\python.exe tests\concurrent_idempotency.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\resilience.py --mode failover --action-script scripts\stop-one.bat --base-url http://localhost:8080 +``` + +Для Linux runner используйте `scripts/restart.sh` и `scripts/stop-one.sh` после `chmod +x scripts/restart.sh scripts/stop-one.sh`. Smoke и отказовые сценарии создают синтетические данные. Для остановки без потери данных: `docker compose --env-file .env down`. Для намеренного удаления тестовой БД и сессий: `docker compose --env-file .env down -v`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Путь запроса: клиент → Nginx LB → две API-реплики → общие PostgreSQL и Redis. PostgreSQL хранит пользователей, чаты, членство, сообщения, сессии и записи идемпотентности. Redis — общий TTL-cache активных сессий; чтение при cache miss обращается к PostgreSQL. Пароли — scrypt, токены — случайные opaque bearer. -## Доказательства критериев +Из lab2 перенесены исходники REST API, схема и версии миграций, auth/store и Dockerfile/runtime dependencies. Новая миграция `003_message_idempotency` создаёт уникальную область `(user_id, method, chat_path, key)`. В одной PostgreSQL-транзакции реплика резервирует ключ, создаёт сообщение и фиксирует ссылку; конкурентный запрос блокируется уникальным индексом и возвращает прежнее сообщение либо 409 при другом JSON. Канонизация учитывает отсутствие `attachment_ids` как пустой список. Ключи сохраняются дольше минимальных 24 часов, автоматическая очистка не настроена. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +Миграции выполняются отдельным одноразовым Compose service `migrate` до запуска API. Nginx распределяет запросы между двумя API-сервисами и исключает недоступный backend при отказе. Для backend используются имена Docker DNS, общими остаются PostgreSQL и Redis. + +| Роль | Compose service / версия | Назначение | +| --- | --- | --- | +| LB | `lb`, nginx:1.27.5-alpine | Публичная точка входа на host port 8080. | +| API ×2 | `api1` и `api2`, локально собранный `mtusi-messenger-api:3.0.0` на Python 3.11.10 | Взаимозаменяемые экземпляры REST API, доступные LB. | +| Миграция | одноразовый `migrate`, `mtusi-messenger-api:3.0.0` | Выполняет `alembic upgrade head` до запуска API. | +| PostgreSQL | `db`, postgres:16.4-alpine | Общая БД, данные в named volume `postgres_data`. | +| Session cache | `redis`, redis:7.4.2-alpine | Общий cache с AOF `appendfsync always` и named volume `redis_data`. | + +`POSTGRES_USER`, `POSTGRES_PASSWORD`, `POSTGRES_DB` используются для PostgreSQL и `DATABASE_URL` API/migrate. `APP_PORT` публикует LB; `SESSION_TTL_SECONDS` задаёт TTL. Секрет PostgreSQL передаётся через локальный игнорируемый `.env`. + +## Доказательства критериев уровня 3 + +| Критерий | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Структура skeleton | `python scripts/check_contract.py` | PASS. | `evidence/implementation-checks.txt` | +| Контракт API через LB | `python tests/smoke.py --base-url http://localhost:8080` | PASS: сценарий публичного API lab3. | `evidence/runtime-checks.txt` | +| Общие сессии и разные реплики | Smoke через LB | PASS: запросы одного пользователя обслуживаются API без повторного входа; виден `X-Instance-Id`. | `evidence/runtime-checks.txt` | +| Persistence | `python tests/resilience.py --mode persistence --action-script scripts/restart.bat ...` | PASS: прежняя сессия и подтверждённые данные доступны после перезапуска сервисов с сохранением volumes. | `evidence/runtime-checks.txt`, `evidence/persistence-actions.txt` | +| Failover API | `python tests/resilience.py --mode failover --action-script scripts/stop-one.bat ...` | PASS: другая реплика продолжает чтение и запись, подтверждённые сообщения сохранены, дубли не появились. | `evidence/runtime-checks.txt`, `evidence/failover-actions.txt` | +| Конкурентная идемпотентность | `python tests/concurrent_idempotency.py --base-url http://localhost:8080` | PASS: конкурентный повтор одного ключа создаёт одну запись. | `evidence/runtime-checks.txt` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +После failover восстановить остановленный сервис по записи в `evidence/failover-actions.txt`, например `docker compose --env-file .env start api2`, и дождаться ответа через LB. -## Эксперименты и отказы +## Эксперименты и ограничения -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Failover-сценарий проверяет отказ одной выбранной API-реплики через LB: перед воздействием наблюдаются как минимум две реплики, а операции продолжаются через оставшуюся. Hook записывает соответствие `TARGET_INSTANCE_ID` и Compose-сервиса. Smoke, тест идемпотентности, persistence и failover запускаются отдельными командами. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | - -## Ограничения и следующие шаги - -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Один Docker host, один LB и одна PostgreSQL — точки отказа; сценарий проверяет отказ одного API-процесса, а не потерю узла/хоста или БД. diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 00000000..c4365907 --- /dev/null +++ b/alembic.ini @@ -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 \ No newline at end of file diff --git a/alembic/env.py b/alembic/env.py new file mode 100644 index 00000000..b75cbcf2 --- /dev/null +++ b/alembic/env.py @@ -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() \ No newline at end of file diff --git a/alembic/script.py.mako b/alembic/script.py.mako new file mode 100644 index 00000000..fe11c3e3 --- /dev/null +++ b/alembic/script.py.mako @@ -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"} \ No newline at end of file diff --git a/alembic/versions/001_initial.py b/alembic/versions/001_initial.py new file mode 100644 index 00000000..14154290 --- /dev/null +++ b/alembic/versions/001_initial.py @@ -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') diff --git a/alembic/versions/002_history_constraints.py b/alembic/versions/002_history_constraints.py new file mode 100644 index 00000000..8d7699be --- /dev/null +++ b/alembic/versions/002_history_constraints.py @@ -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) diff --git a/alembic/versions/003_message_idempotency.py b/alembic/versions/003_message_idempotency.py new file mode 100644 index 00000000..890acc9c --- /dev/null +++ b/alembic/versions/003_message_idempotency.py @@ -0,0 +1,30 @@ +"""Persist message idempotency claims in the shared PostgreSQL database.""" +from alembic import op +import sqlalchemy as sa + +revision = "003_message_idempotency" +down_revision = "002" +branch_labels = None +depends_on = None + + +def upgrade(): + op.create_table( + "message_idempotency", + sa.Column("id", sa.String(), nullable=False), + sa.Column("user_id", sa.String(), nullable=False), + sa.Column("method", sa.String(length=8), nullable=False), + sa.Column("chat_path", sa.String(length=80), nullable=False), + sa.Column("key", sa.String(length=128), nullable=False), + sa.Column("request_hash", sa.String(length=64), nullable=False), + sa.Column("message_id", sa.String(), nullable=True), + sa.Column("created_at", sa.DateTime(timezone=True), nullable=False), + sa.ForeignKeyConstraint(["message_id"], ["messages.id"]), + sa.ForeignKeyConstraint(["user_id"], ["users.id"]), + sa.PrimaryKeyConstraint("id"), + sa.UniqueConstraint("user_id", "method", "chat_path", "key", name="uq_idempotency_scope"), + ) + + +def downgrade(): + op.drop_table("message_idempotency") diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..801e46fb --- /dev/null +++ b/compose.yaml @@ -0,0 +1,75 @@ +services: + api1: + build: . + image: mtusi-messenger-api:3.0.0 + environment: + DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:?Create a local .env first}@db:5432/${POSTGRES_DB:-messenger} + CACHE_URL: redis://redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + depends_on: + migrate: + condition: service_completed_successfully + db: + condition: service_started + redis: + condition: service_started + restart: unless-stopped + + api2: + build: . + image: mtusi-messenger-api:3.0.0 + environment: + DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:?Create a local .env first}@db:5432/${POSTGRES_DB:-messenger} + CACHE_URL: redis://redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + depends_on: + migrate: + condition: service_completed_successfully + db: + condition: service_started + redis: + condition: service_started + restart: unless-stopped + + migrate: + build: . + image: mtusi-messenger-api:3.0.0 + command: ["alembic", "upgrade", "head"] + environment: + DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:?Create a local .env first}@db:5432/${POSTGRES_DB:-messenger} + depends_on: + db: + condition: service_started + restart: "no" + + lb: + image: nginx:1.27.5-alpine + ports: + - "${APP_PORT:-8080}:8080" + volumes: + - ./infra/nginx.conf:/etc/nginx/conf.d/default.conf:ro + depends_on: + - api1 + - api2 + restart: unless-stopped + + 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 + restart: unless-stopped + + redis: + image: redis:7.4.2-alpine + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"] + volumes: + - redis_data:/data + restart: unless-stopped + +volumes: + postgres_data: + redis_data: diff --git a/entrypoint.sh b/entrypoint.sh new file mode 100644 index 00000000..f8e3a2c2 --- /dev/null +++ b/entrypoint.sh @@ -0,0 +1,18 @@ +#!/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 +exec "$@" diff --git a/evidence/failover-actions.txt b/evidence/failover-actions.txt new file mode 100644 index 00000000..682f8d8b --- /dev/null +++ b/evidence/failover-actions.txt @@ -0,0 +1 @@ +2026-10-27 00:34:02 +03:00 target=e84a6cc7-57a8-4b85-9007-94854ac55397 service=api2 container=/mtusi2026lab3-fork-api2-1 diff --git a/evidence/implementation-checks.txt b/evidence/implementation-checks.txt new file mode 100644 index 00000000..0507b658 --- /dev/null +++ b/evidence/implementation-checks.txt @@ -0,0 +1,9 @@ +# Implementation checks + +Date: 2026-10-27 (Europe/Moscow). + +- `scripts/check_contract.py` — PASS: offline skeleton structure, local refs and Python syntax. +- `scripts/validate_openapi.py` — PASS: OpenAPI 3.1 and JSON Schema. +- `python -m compileall -q src alembic scripts tests` — PASS. +- `docker compose --env-file .env config --quiet` — PASS. +- Runtime smoke, concurrent idempotency, persistence and one failover scenario — PASS; details in `runtime-checks.txt`. diff --git a/evidence/persistence-actions.txt b/evidence/persistence-actions.txt new file mode 100644 index 00000000..a1a23c0e --- /dev/null +++ b/evidence/persistence-actions.txt @@ -0,0 +1,11 @@ +[2026-10-27 00:33:51 +03:00] +before service=db container=/mtusi2026lab3-fork-db-1 started_at=2026-10-26T21:32:43.19822304Z +before service=redis container=/mtusi2026lab3-fork-redis-1 started_at=2026-10-26T21:32:43.234502434Z +before service=api1 container=/mtusi2026lab3-fork-api1-1 started_at=2026-10-26T21:32:47.662735904Z +before service=api2 container=/mtusi2026lab3-fork-api2-1 started_at=2026-10-26T21:32:47.639547191Z +before service=lb container=/mtusi2026lab3-fork-lb-1 started_at=2026-10-26T21:32:48.230941054Z +after service=db container=/mtusi2026lab3-fork-db-1 started_at=2026-10-26T21:33:44.87798288Z +after service=redis container=/mtusi2026lab3-fork-redis-1 started_at=2026-10-26T21:33:45.696353566Z +after service=api1 container=/mtusi2026lab3-fork-api1-1 started_at=2026-10-26T21:33:45.732430678Z +after service=api2 container=/mtusi2026lab3-fork-api2-1 started_at=2026-10-26T21:33:45.632728749Z +after service=lb container=/mtusi2026lab3-fork-lb-1 started_at=2026-10-26T21:33:45.634017354Z diff --git a/evidence/runtime-checks.txt b/evidence/runtime-checks.txt new file mode 100644 index 00000000..a28e4aa2 --- /dev/null +++ b/evidence/runtime-checks.txt @@ -0,0 +1,16 @@ +# Runtime verification + +Test window: 2026-10-27 00:32–00:35 (Europe/Moscow). +Docker Engine 26.1.4; Docker Compose v2.27.1-desktop.1; Python 3.11.5. +Compose topology: Nginx LB, api1, api2, PostgreSQL, Redis. Test data is synthetic; credentials and tokens are not recorded. + +- `docker compose --env-file .env config --quiet` — PASS. +- `python scripts/check_contract.py` — PASS. +- `python scripts/validate_openapi.py` — PASS. +- `python -m compileall -q src alembic scripts tests` — PASS. +- `python tests/smoke.py --base-url http://localhost:8080` — PASS via LB. +- `python tests/concurrent_idempotency.py --base-url http://localhost:8080` — PASS: 32 concurrent identical requests produced one Message across 2 API instances; history contains one record. +- `python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080` — PASS: confirmed data and the existing session survived restart; actual container start times are in `persistence-actions.txt`. +- `python tests/resilience.py --mode failover --action-script scripts/stop-one.bat --base-url http://localhost:8080` — PASS for api2: two instances observed before failure; first recovered write at 3.985 s (≤10-second level-3 requirement); confirmed data and session preserved. +- Restored api2; `/health/ready` via LB and final smoke — PASS. + diff --git a/infra/nginx.conf b/infra/nginx.conf new file mode 100644 index 00000000..7a1bc0cb --- /dev/null +++ b/infra/nginx.conf @@ -0,0 +1,20 @@ +upstream api_backend { + zone api_backend 64k; + resolver 127.0.0.11 valid=2s ipv6=off; + server api1:8080 resolve max_fails=1 fail_timeout=2s; + server api2:8080 resolve max_fails=1 fail_timeout=2s; + keepalive 32; +} + +server { + listen 8080; + location / { + proxy_pass http://api_backend; + proxy_http_version 1.1; + proxy_set_header Connection ""; + proxy_set_header Host $host; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + proxy_next_upstream error timeout http_502 http_503 http_504; + } +} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..d3f7ee25 --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/scripts/restart.bat b/scripts/restart.bat new file mode 100644 index 00000000..21fe545b --- /dev/null +++ b/scripts/restart.bat @@ -0,0 +1,4 @@ +@echo off +setlocal +powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0restart.ps1" +exit /b %errorlevel% diff --git a/scripts/restart.ps1 b/scripts/restart.ps1 new file mode 100644 index 00000000..611f91e9 --- /dev/null +++ b/scripts/restart.ps1 @@ -0,0 +1,21 @@ +$ErrorActionPreference = 'Stop' +Set-Location (Join-Path $PSScriptRoot '..') +function Get-ContainerState($phase) { + foreach ($service in @('db', 'redis', 'api1', 'api2', 'lb')) { + $containers = docker compose --env-file .env ps -q $service + if ($LASTEXITCODE -ne 0) { throw "Cannot list $service containers" } + foreach ($container in $containers) { + $name = docker inspect --format '{{.Name}}' $container + $started = docker inspect --format '{{.State.StartedAt}}' $container + "$phase service=$service container=$name started_at=$started" + } + } +} +$before = @(Get-ContainerState 'before') +docker compose --env-file .env restart db redis api1 api2 lb | Out-Null +if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } +$after = @(Get-ContainerState 'after') +$stamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss K' +Add-Content -Path (Join-Path $PSScriptRoot '..\evidence\persistence-actions.txt') -Value "[$stamp]" +Add-Content -Path (Join-Path $PSScriptRoot '..\evidence\persistence-actions.txt') -Value $before +Add-Content -Path (Join-Path $PSScriptRoot '..\evidence\persistence-actions.txt') -Value $after diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..43a85078 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env restart db redis api1 api2 lb diff --git a/scripts/stop-one.bat b/scripts/stop-one.bat new file mode 100644 index 00000000..e2c0c17e --- /dev/null +++ b/scripts/stop-one.bat @@ -0,0 +1,4 @@ +@echo off +setlocal +powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0stop-one.ps1" +exit /b %errorlevel% diff --git a/scripts/stop-one.ps1 b/scripts/stop-one.ps1 new file mode 100644 index 00000000..f96c9ecd --- /dev/null +++ b/scripts/stop-one.ps1 @@ -0,0 +1,22 @@ +$ErrorActionPreference = 'Stop' +Set-Location (Join-Path $PSScriptRoot '..') +$target = $env:TARGET_INSTANCE_ID +if ([string]::IsNullOrWhiteSpace($target)) { exit 2 } +foreach ($service in @('api1', 'api2')) { + $containers = docker compose --env-file .env ps -q $service + if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } + foreach ($container in $containers) { + try { + $instance = docker exec $container python -c "import urllib.request; print(urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=2).headers['X-Instance-Id'])" 2>$null + if ($LASTEXITCODE -eq 0 -and $instance.Trim() -eq $target) { + $name = docker inspect --format '{{.Name}}' $container + $stamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss K' + Add-Content -Path (Join-Path $PSScriptRoot '..\evidence\failover-actions.txt') -Value "$stamp target=$target service=$service container=$name" + docker stop --time 5 $container | Out-Null + exit $LASTEXITCODE + } + } catch { } + } +} +Write-Error 'No running API container matched TARGET_INSTANCE_ID' +exit 1 diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..87d71e3e --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,15 @@ +#!/bin/sh +set -eu +target=${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID is required} +cd "$(dirname "$0")/.." +for service in api1 api2; do + for container in $(docker compose --env-file .env ps -q "$service"); do + instance=$(docker exec "$container" python -c 'import urllib.request; r=urllib.request.urlopen("http://127.0.0.1:8080/health/live",timeout=2); print(r.headers["X-Instance-Id"])' 2>/dev/null || true) + if [ "$instance" = "$target" ]; then + docker stop --time 5 "$container" >/dev/null + exit 0 + fi + done +done +echo "No running API container matched TARGET_INSTANCE_ID" >&2 +exit 1 diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..d7a803fa --- /dev/null +++ b/src/__init__.py @@ -0,0 +1 @@ +from .main import app \ No newline at end of file diff --git a/src/auth.py b/src/auth.py new file mode 100644 index 00000000..02a49ee1 --- /dev/null +++ b/src/auth.py @@ -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) diff --git a/src/database.py b/src/database.py new file mode 100644 index 00000000..1c7c1244 --- /dev/null +++ b/src/database.py @@ -0,0 +1,81 @@ +"""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"),) + + +class MessageIdempotency(Base): + __tablename__ = "message_idempotency" + id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4())) + user_id = Column(String, ForeignKey("users.id"), nullable=False) + method = Column(String(8), nullable=False) + chat_path = Column(String(80), nullable=False) + key = Column(String(128), nullable=False) + request_hash = Column(String(64), nullable=False) + message_id = Column(String, ForeignKey("messages.id"), nullable=True) + created_at = Column(DateTime(timezone=True), nullable=False, default=now) + __table_args__ = (UniqueConstraint("user_id", "method", "chat_path", "key", + name="uq_idempotency_scope"),) diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..eb954c11 --- /dev/null +++ b/src/main.py @@ -0,0 +1,247 @@ +"""Lab 2 REST API: PostgreSQL-backed records and opaque bearer sessions.""" +import base64 +import binascii +import hashlib +import json +import re +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="3.0.0") +INSTANCE_ID = str(uuid.uuid4()) + + +@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 + response.headers["X-Instance-Id"] = INSTANCE_ID + return response + + +@app.exception_handler(AppError) +async def app_error_handler(request, exc): + headers = {"X-Request-Id": request.state.request_id, **exc.headers} + headers["X-Instance-Id"] = INSTANCE_ID + 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,"X-Instance-Id":INSTANCE_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,"X-Instance-Id":INSTANCE_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,"X-Instance-Id":INSTANCE_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() or data.attachment_ids: + raise AppError(400,"invalid_request","Invalid message text") + key = request.headers.get("Idempotency-Key", "") + if not re.fullmatch(r"[A-Za-z0-9._:-]{1,128}", key, flags=re.ASCII): + raise AppError(400,"invalid_request","A valid Idempotency-Key is required") + canonical = json.dumps({"text":data.text,"attachment_ids":[]}, ensure_ascii=False, + sort_keys=True, separators=(",", ":")) + request_hash = hashlib.sha256(canonical.encode("utf-8")).hexdigest() + try: + msg=store.add_message_idempotent(chat_id,user_id,data.text,[],key,request_hash) + 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 as exc: + if str(exc) == "IDEMPOTENCY_CONFLICT": + raise AppError(409,"conflict","Idempotency key was used with a different request") + 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} diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..18e062df --- /dev/null +++ b/src/models.py @@ -0,0 +1,28 @@ +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) + attachment_ids: List[str] = Field(default_factory=list, max_length=10) + + +class LoginRequest(BaseModel): + username: str + password: str diff --git a/src/session_cache.py b/src/session_cache.py new file mode 100644 index 00000000..b17a9720 --- /dev/null +++ b/src/session_cache.py @@ -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 diff --git a/src/store.py b/src/store.py new file mode 100644 index 00000000..a473e54f --- /dev/null +++ b/src/store.py @@ -0,0 +1,189 @@ +"""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_, select, update +from sqlalchemy.dialects.postgresql import insert +from sqlalchemy.orm import selectinload +from sqlalchemy.exc import IntegrityError +from .database import User, Session as SessionRow, Chat, ChatMember, Message, MessageIdempotency, 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 add_message_idempotent(self, chat_id, sender_id, text, attachment_ids, key, request_hash): + """Claim a scoped key and create its message in the same DB transaction.""" + with SessionLocal() as db: + if not db.query(ChatMember.id).filter(ChatMember.chat_id == chat_id, + ChatMember.user_id == sender_id).first(): + raise ValueError("CHAT_NOT_FOUND") + scope = dict(user_id=sender_id, method="POST", chat_path=f"/api/v1/chats/{chat_id}/messages", key=key) + claim = insert(MessageIdempotency).values(**scope, request_hash=request_hash, + message_id=None).on_conflict_do_nothing( + constraint="uq_idempotency_scope").returning(MessageIdempotency.id) + claimed = db.execute(claim).scalar_one_or_none() + if claimed is None: + record = db.execute(select(MessageIdempotency).filter_by(**scope)).scalar_one() + if record.request_hash != request_hash: + raise ValueError("IDEMPOTENCY_CONFLICT") + msg = db.get(Message, record.message_id) + if msg is None: + raise RuntimeError("Idempotency record has no message") + return msg + msg = Message(chat_id=chat_id, sender_id=sender_id, text=text) + db.add(msg) + db.flush() + db.execute(update(MessageIdempotency).where(MessageIdempotency.id == claimed).values(message_id=msg.id)) + 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() diff --git a/tests/concurrent_idempotency.py b/tests/concurrent_idempotency.py new file mode 100644 index 00000000..f4db56e7 --- /dev/null +++ b/tests/concurrent_idempotency.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +"""Verify concurrent same-key writes are shared across real API instances.""" +from concurrent.futures import ThreadPoolExecutor +import uuid +from urllib.parse import quote + +from client import Client, arguments, check, run + + +def main(): + args = arguments('Concurrent message idempotency across API replicas') + client = Client(args.base_url, args.ca_file, timeout=10) + alice, _bob, _eve, chat = client.bootstrap() + text = 'Concurrent idempotency ' + uuid.uuid4().hex + key = 'race-' + uuid.uuid4().hex + path = '/api/v1/chats/' + chat['id'] + '/messages' + + def post_once(_): + return client.call('POST', path, 201, actor=alice, + body={'text': text}, + headers={'Idempotency-Key': key}, schema='Message') + + with ThreadPoolExecutor(max_workers=16) as pool: + responses = list(pool.map(post_once, range(32))) + + messages = [response['json'] for response in responses] + check(all(message == messages[0] for message in messages), + 'concurrent same-key requests returned different messages') + instances = {response['headers']['X-Instance-Id'] for response in responses} + check(len(instances) >= 2, + 'concurrent requests did not reach at least two API replicas') + + history = [] + cursor = None + while True: + query = '?limit=100' + ('&cursor=' + quote(cursor, safe='') if cursor else '') + page = client.call('GET', path + query, actor=alice, schema='MessagePage')['json'] + history.extend(page['items']) + cursor = page['next_cursor'] + if cursor is None: + break + check(sum(message['text'] == text for message in history) == 1, + 'same-key concurrent write created more than one history item') + print('PASS: 32 concurrent same-key POSTs returned one message across ' + + str(len(instances)) + ' API instances; history contains one record.') + + +if __name__ == '__main__': + run(main)