From 3af3a132ca3689d96325f208daedb8a3113ad91b Mon Sep 17 00:00:00 2001 From: Ekaterina Zyulina Date: Mon, 19 Oct 2026 23:09:12 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9B=D0=B0=D0=B1=D0=BE=D1=80=D0=B0=D1=82?= =?UTF-8?q?=D0=BE=D1=80=D0=BD=D0=B0=D1=8F=202:=D0=9E=D1=86=D0=B5=D0=BD?= =?UTF-8?q?=D0=BA=D0=B0=204?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .dockerignore | 10 +- .env.example | 14 +- .gitignore | 1 + Dockerfile | 23 ++ Makefile | 6 +- REPORT.md | 102 +++++++-- alembic.ini | 37 ++++ alembic/env.py | 46 ++++ alembic/script.py.mako | 22 ++ alembic/versions/001_initial.py | 70 ++++++ alembic/versions/002_history_constraints.py | 35 +++ compose.yaml | 51 +++++ entrypoint.sh | 19 ++ evidence/history-plan.txt | 17 ++ requirements.txt | 7 + scripts/restart.bat | 11 + scripts/restart.sh | 16 ++ src/__init__.py | 1 + src/auth.py | 31 +++ src/database.py | 67 ++++++ src/main.py | 233 ++++++++++++++++++++ src/models.py | 27 +++ src/session_cache.py | 72 ++++++ src/store.py | 161 ++++++++++++++ tests/README.md | 10 + tests/level4.py | 228 +++++++++++++++++++ 26 files changed, 1283 insertions(+), 34 deletions(-) create mode 100644 Dockerfile create mode 100644 alembic.ini create mode 100644 alembic/env.py create mode 100644 alembic/script.py.mako create mode 100644 alembic/versions/001_initial.py create mode 100644 alembic/versions/002_history_constraints.py create mode 100644 compose.yaml create mode 100644 entrypoint.sh create mode 100644 evidence/history-plan.txt create mode 100644 requirements.txt create mode 100644 scripts/restart.bat create mode 100644 scripts/restart.sh create mode 100644 src/__init__.py create mode 100644 src/auth.py create mode 100644 src/database.py create mode 100644 src/main.py create mode 100644 src/models.py create mode 100644 src/session_cache.py create mode 100644 src/store.py create mode 100644 tests/level4.py diff --git a/.dockerignore b/.dockerignore index bc16e556..cc30d46e 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,6 +1,14 @@ +.venv/ +__pycache__/ +*.pyc +.env .git .github -.env +tests/ +student-tests/ +evidence/ +examples/ +*.md .env.* !.env.example secrets diff --git a/.env.example b/.env.example index 714c8076..f841fe16 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,7 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. -APP_HOST=0.0.0.0 +# Copy to .env and replace the password with a unique local random value. APP_PORT=8080 -APP_ENV=lab SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url +POSTGRES_USER=messenger +POSTGRES_PASSWORD=replace-with-a-random-32-character-value +POSTGRES_DB=messenger +CACHE_URL=redis://redis:6379/0 diff --git a/.gitignore b/.gitignore index b5a71896..f6cd7bbf 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ +*.pyc # Local/private state .env .env.* 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 9ecb223e..24aa0078 100644 --- a/Makefile +++ b/Makefile @@ -4,10 +4,11 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test load test-persistence test-level4 help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "test-level4: Redis, expiry, failures, registration race, rollback, and history index" check: $(PYTHON) scripts/check_contract.py @@ -24,3 +25,6 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +test-level4: + $(PYTHON) tests/level4.py --base-url "$(BASE_URL)" $(TLS_ARGS) diff --git a/REPORT.md b/REPORT.md index e42f2b05..c0d1eecd 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,93 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Зюлина Екатерина Михайловна БВТ2302. +- Целевая оценка: **4**. +- Использованные источники и помощь: задание, контракт и публичные проверки этого репозитория; помощь Codex при анализе требований, реализации и подготовке отчёта. -## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +## Воспроизводимый запуск (Windows PowerShell) -## Архитектура и решения +Нужны Docker Desktop с Linux containers и Python 3.11. Приложение собирается из этого репозитория; миграции применяются автоматически при старте API. В новом clone подготовьте виртуальное окружение и локальный `.env`: -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```powershell +Copy-Item .env.example .env +# В .env заменить POSTGRES_PASSWORD случайным значением длиной не менее 32 символов. +py -3.11 -m venv .venv +.\.venv\Scripts\python.exe -m pip install -r requirements-dev.txt +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +$ready = $false; $deadline = (Get-Date).AddMinutes(2); while (-not $ready -and (Get-Date) -lt $deadline) { try { $ready = (Invoke-WebRequest http://localhost:8080/health/ready -UseBasicParsing -TimeoutSec 2).StatusCode -eq 200 } catch { Start-Sleep -Seconds 2 } }; if (-not $ready) { throw 'API did not become ready' } +.\.venv\Scripts\python.exe scripts\check_contract.py +.\.venv\Scripts\python.exe scripts\validate_openapi.py +.\.venv\Scripts\python.exe tests\smoke.py --base-url http://localhost:8080 +.\.venv\Scripts\python.exe tests\resilience.py --mode persistence --action-script scripts\restart.bat --base-url http://localhost:8080 +.\.venv\Scripts\python.exe tests\level4.py --base-url http://localhost:8080 +``` -## Доказательства критериев +`scripts/restart.bat` перезапускает PostgreSQL, Redis и API без удаления volumes. Не выполняйте `docker compose down -v`, пока данные нужны: эта команда намеренно удаляет сохраняемые данные. Секреты находятся только в локальном игнорируемом `.env`. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +## Архитектура и инфраструктура -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Путь запроса: клиент → FastAPI → PostgreSQL; Redis используется API для активных сессий. PostgreSQL — **источник истины** для пользователей, хешей паролей, сессий и предметных данных (чаты, участники, сообщения). Redis — TTL-кэш сессий, не единственное хранилище токенов. Volume `postgres_data` сохраняет PostgreSQL; `redis_data` сохраняет AOF Redis. Оба хранилища подключены только во внутреннюю Compose-сеть; наружу опубликован порт API. -## Эксперименты и отказы +| Роль | Compose service / образ | Готовность и постоянные данные | +| --- | --- | --- | +| HTTP API | `api`, собирается из `Dockerfile`, `python:3.11.10-slim-bookworm` | `/health/ready` проверяет БД и Redis; исходники поставляются с репозиторием. Порт на хосте задаёт `APP_PORT` (по умолчанию 8080). | +| SQL-хранилище | `db`, `postgres:16.4-alpine` | `pg_isready`; именованный `postgres_data`; порт 5432 не публикуется на хост. | +| Кэш сессий | `redis`, `redis:7.4.2-alpine` | `PING`; именованный `redis_data`; AOF и `appendfsync always`; порт 6379 не публикуется на хост. | -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Compose использует внутренний DNS сервисов `db` и `redis`. Пароль PostgreSQL передаётся API и БД из `.env`; у Redis credentials не заданы, так как он доступен только во внутренней сети локального учебного Compose-стенда. Указанные теги образов закреплены, `latest` не используется. На машине проверки: Windows, Docker Desktop Linux Engine 26.1.4 / Compose 2.27.1, Intel Core i5-11320H, 15.8 GiB RAM. Явные CPU/RAM-лимиты контейнеров не устанавливались; результаты плана запроса относятся только к этому локальному стенду. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +Схема создаётся версионируемыми миграциями Alembic: `001` создаёт начальную структуру; `002` укрепляет временные поля, уникальность членства и индексы истории/списка чатов. Entry point ждёт PostgreSQL, затем выполняет `alembic upgrade head`. Повторный запуск не создаёт вторую схему. -## Ограничения и следующие шаги +## Модель данных и транзакции -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- `users`: уникальное имя пользователя, display name, соль и результат password KDF; пароль не сохраняется. +- `sessions`: уникальный случайный bearer-токен, пользователь и абсолютный срок `expires_at`; внешний ключ связывает с пользователем. +- `chats`, `chat_members`: чат и участники; `(chat_id,user_id)` уникален, внешние ключи не допускают отсутствующих владельцев. +- `messages`: чат, отправитель, текст и серверное время; внешние ключи связывают сообщение с чатом и пользователем. + +Каждая операция Store открывает свою SQLAlchemy-сессию. Создание чата и всех участников находится в одной транзакции: неизвестный/повторный участник приводит к rollback целиком. Уникальное ограничение username разрешает гонку на стороне PostgreSQL; проигравшая регистрация преобразуется в `409`, а не в дубликат. ORM использует параметры, пул ограничен пятью постоянными и пятью overflow соединениями, заданы `pool_timeout=5`, PostgreSQL `connect_timeout=5` и `statement_timeout=5s`. + +## Пароли, сессии и Redis + +Пароль обрабатывается стандартной библиотекой `hashlib.scrypt`: индивидуальная случайная соль 128 бит, `N=16384`, `r=8`, `p=1`; сравнение хешей constant-time. Это медленный password KDF с солью, а не быстрый checksum. Basic принимается только на `POST /api/v1/auth/sessions`. После успешного входа сервер возвращает opaque bearer-токен с 256 битами случайности; бизнес-endpoint определяют пользователя по действующей серверной сессии, а `X-User-Id` не даёт полномочий. + +При создании сессии строка сначала фиксируется в PostgreSQL, затем копируется в Redis с TTL, равным оставшемуся сроку жизни. Если Redis недоступен при создании, строка удаляется, а клиент получает `503`, чтобы не выдавать сессию без кэша. Проверка токена сначала читает Redis; cache miss обращается к PostgreSQL и заполняет Redis оставшимся TTL. PostgreSQL остаётся авторитетным и позволяет восстановить действующую сессию после потери/перезапуска Redis. Logout удаляет ключ кэша и запись источника истины. TTL не продлевается чтением или рестартом API; просроченная запись не авторизует запрос даже при задержанном физическом удалении строки. + +Redis настроен на AOF с `appendfsync always`. Тест перезапускает Redis без удаления `redis_data`, затем подтверждает, что прежняя действующая сессия работает; отдельный источник истины в PostgreSQL также позволяет пересобрать ключ кэша при cache miss. Быстрая проверка TCP-порта Redis с таймаутом 0.2 секунды позволяет вернуть ограниченную ошибку при остановленном сервисе, не ожидая цикла повторных попыток клиента. + +## Пагинация и индекс истории + +История использует непрозрачный URL-safe cursor, связанный с chat id и содержащий `(created_at,id)`. Следующая страница фильтруется сравнением этой пары и сортируется по ней же; последний элемент предыдущей страницы не повторяется. Составной индекс `ix_messages_chat_created_id(chat_id, created_at, id)` соответствует равенству по чату, диапазону по cursor и порядку выдачи. Между HTTP-запросами нет snapshot-гарантии; контракт гарантирует обход без повторов для неизменной истории. + +Тест создал отдельный синтетический чат с 12 000 сообщениями, выполнил `ANALYZE` и запрос `EXPLAIN (ANALYZE, BUFFERS)` с keyset-диапазоном и `LIMIT 50`. В сохранённом [плане запроса](evidence/history-plan.txt) PostgreSQL выбрал `Index Only Scan using ix_messages_chat_created_id`, прочитал 50 строк; указаны 6 buffer hits и execution time 0.125 ms на итоговом прогоне. Это свидетельствует об использовании подходящего индекса для данного набора и запроса, но не является нагрузочным бенчмарком или обещанием такой задержки на другом окружении. + +## Результаты проверок уровня 3 и 4 + +| Требование | Проверка | Результат| +| --- | --- | --- | +| Контракт и структура проекта | `scripts/check_contract.py` | PASS | +| Валидность Compose | `docker compose --env-file .env config --quiet` | PASS | +| OpenAPI 3.1 и JSON Schema | `scripts/validate_openapi.py` | PASS, полная валидация; приложение не подменяется тестом схемы | +| Сквозной API smoke | `tests/smoke.py --base-url http://localhost:8080` | PASS — `lab2 public API scenario` на итоговой сборке | +| Перезапуск БД/API/Redis и сохранение данных/прежнего токена | `tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080` | PASS — данные и действующая сессия подтверждены после выполнения hook на итоговой сборке | +| Две одновременные регистрации с одним username | `tests/level4.py` | PASS: ровно `201` и `409` | +| Rollback чата с неизвестным участником | `tests/level4.py` | PASS: в списке не осталось частичного чата | +| Redis TTL, AOF и отказ сервисов | `tests/level4.py` | PASS: активные ключи в Redis; сессия доступна после restart Redis; при отключении Redis и PostgreSQL readiness и запрос с Bearer дают `503`, после возврата сервисов API снова готов | +| Истечение сессии, logout и неверный пароль | `tests/level4.py` | PASS: неверный пароль `401`, logout `204` с последующим `401`, сессия с TTL 2 секунды после ожидания даёт `401` | +| История ≥10 000 строк и индексный план | `tests/level4.py` | PASS: 12 000 синтетических строк; keyset-страница 50 записей; план использовал составной индекс, сохранён в `evidence/history-plan.txt` | + +Полный дополнительный сценарий запускается командой: + +```powershell +.\.venv\Scripts\python.exe tests\level4.py --base-url http://localhost:8080 +``` + +Он управляет только `api`, `db`, `redis` этой Compose-группы, не удаляет volumes и создаёт уникальные синтетические fixtures. Для проверки истечения временно меняет `SESSION_TTL_SECONDS` в локальном `.env`, затем восстанавливает исходное содержимое файла. 12 000 сообщений и записи сценариев намеренно остаются в учебной БД. Повторный прогон добавляет новый синтетический набор. + +Итог проверки уровня 4: **PASS** на итоговой сборке. + +## Границы решения и вопросы к защите + +Это локальный учебный стенд с синтетическими данными и HTTP на localhost. Basic кодирует, но не шифрует пароль; удалённая демонстрация требует TLS. Один Docker host и один PostgreSQL не обеспечивают HA. AOF `appendfsync always` настраивает локальную политику Redis, но не защищает от потери всего Docker host/диска; устойчивость PostgreSQL зависит от WAL и хранения volume. `EXPLAIN ANALYZE` измерен на одной машине, без повторов/статистического анализа и без сравнения индексов. 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/compose.yaml b/compose.yaml new file mode 100644 index 00000000..32e483fb --- /dev/null +++ b/compose.yaml @@ -0,0 +1,51 @@ +services: + api: + build: . + environment: + DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:?Create a local .env first}@db:5432/${POSTGRES_DB:-messenger} + CACHE_URL: ${CACHE_URL:-redis://redis:6379/0} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + ports: + - "${APP_PORT:-8080}:8080" + depends_on: + db: + condition: service_healthy + redis: + condition: service_healthy + restart: unless-stopped + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"] + interval: 10s + timeout: 3s + retries: 5 + + db: + image: postgres:16.4-alpine + environment: + POSTGRES_USER: ${POSTGRES_USER:-messenger} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Create a local .env first} + POSTGRES_DB: ${POSTGRES_DB:-messenger} + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"] + interval: 5s + timeout: 5s + retries: 10 + restart: unless-stopped + + redis: + image: redis:7.4.2-alpine + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"] + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + restart: unless-stopped + +volumes: + postgres_data: + redis_data: diff --git a/entrypoint.sh b/entrypoint.sh new file mode 100644 index 00000000..0d70bf30 --- /dev/null +++ b/entrypoint.sh @@ -0,0 +1,19 @@ +#!/bin/sh +set -eu +python - <<'PY' +import os, time +from sqlalchemy import create_engine, text +url = os.environ["DATABASE_URL"] +engine = create_engine(url, connect_args={"connect_timeout": 3}) +for attempt in range(60): + try: + with engine.connect() as connection: + connection.execute(text("SELECT 1")) + break + except Exception: + if attempt == 59: + raise + time.sleep(1) +PY +alembic upgrade head +exec "$@" diff --git a/evidence/history-plan.txt b/evidence/history-plan.txt new file mode 100644 index 00000000..3eb80f27 --- /dev/null +++ b/evidence/history-plan.txt @@ -0,0 +1,17 @@ +Synthetic chat rows: 12000 +Query: keyset range on (created_at, id), LIMIT 50 + + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.42..32.35 rows=50 width=45) (actual time=0.038..0.052 rows=50 loops=1) + Buffers: shared hit=7 + -> Index Only Scan using ix_messages_chat_created_id on messages (cost=0.42..959.48 rows=1502 width=45) (actual time=0.037..0.049 rows=50 loops=1) + Index Cond: ((chat_id = '16e6e2a6-54aa-4985-b7c0-9f0e0ecb0047'::text) AND (ROW(created_at, id) > ROW((CURRENT_TIMESTAMP - '01:40:00'::interval), ''::text))) + Heap Fetches: 50 + Buffers: shared hit=7 + Planning: + Buffers: shared hit=136 + Planning Time: 0.620 ms + Execution Time: 0.111 ms +(10 rows) + 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..0ab5f888 --- /dev/null +++ b/scripts/restart.bat @@ -0,0 +1,11 @@ +@echo off +setlocal +cd /d "%~dp0.." +docker compose --env-file .env restart db +if errorlevel 1 exit /b 1 +docker compose --env-file .env restart redis +if errorlevel 1 exit /b 1 +docker compose --env-file .env restart api +if errorlevel 1 exit /b 1 +powershell -NoProfile -Command "$deadline=(Get-Date).AddSeconds(90); do { try { $r=Invoke-WebRequest -UseBasicParsing http://localhost:8080/health/ready -TimeoutSec 2; if ($r.StatusCode -eq 200) { exit 0 } } catch {}; Start-Sleep -Seconds 2 } while ((Get-Date) -lt $deadline); exit 1" +exit /b %ERRORLEVEL% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..bb1e3f1e --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,16 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env restart db +docker compose --env-file .env up -d --wait db +docker compose --env-file .env restart redis +docker compose --env-file .env up -d --wait redis +docker compose --env-file .env restart api +deadline=$(( $(date +%s) + 90 )) +until curl --fail --silent http://localhost:8080/health/ready >/dev/null; do + if [ "$(date +%s)" -ge "$deadline" ]; then + echo "API did not become ready within 90 seconds" >&2 + exit 1 + fi + sleep 2 +done 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..3c79767a --- /dev/null +++ b/src/database.py @@ -0,0 +1,67 @@ +"""PostgreSQL schema and bounded connection pool.""" +import os +import uuid +from datetime import datetime, timezone +from sqlalchemy import (Column, DateTime, ForeignKey, Index, String, Text, + UniqueConstraint, create_engine) +from sqlalchemy.orm import declarative_base, relationship, sessionmaker + +DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://postgres:postgres@db:5432/messenger") +engine = create_engine(DATABASE_URL, pool_size=5, max_overflow=5, pool_timeout=5, + pool_pre_ping=True, connect_args={"connect_timeout": 5, + "options": "-c statement_timeout=5000"}) +SessionLocal = sessionmaker(bind=engine, expire_on_commit=False) +Base = declarative_base() +now = lambda: datetime.now(timezone.utc) + + +class User(Base): + __tablename__ = "users" + id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4())) + username = Column(String(32), nullable=False) + display_name = Column(String(100), nullable=False) + password_hash = Column(String(255), nullable=False) + created_at = Column(DateTime(timezone=True), nullable=False, default=now) + __table_args__ = (Index("ix_users_username", "username", unique=True),) + + +class Session(Base): + __tablename__ = "sessions" + id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4())) + token = Column(String(255), nullable=False) + user_id = Column(String, ForeignKey("users.id"), nullable=False) + expires_at = Column(DateTime(timezone=True), nullable=False) + created_at = Column(DateTime(timezone=True), nullable=False, default=now) + user = relationship("User") + __table_args__ = (Index("ix_sessions_token", "token", unique=True),) + + +class Chat(Base): + __tablename__ = "chats" + id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4())) + title = Column(String(100), nullable=False) + created_at = Column(DateTime(timezone=True), nullable=False, default=now) + members = relationship("ChatMember", back_populates="chat", cascade="all, delete-orphan") + + +class ChatMember(Base): + __tablename__ = "chat_members" + id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4())) + chat_id = Column(String, ForeignKey("chats.id"), nullable=False) + user_id = Column(String, ForeignKey("users.id"), nullable=False) + chat = relationship("Chat", back_populates="members") + user = relationship("User") + __table_args__ = (UniqueConstraint("chat_id", "user_id", name="uq_chat_member"), + Index("ix_chat_members_user_chat", "user_id", "chat_id")) + + +class Message(Base): + __tablename__ = "messages" + id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4())) + chat_id = Column(String, ForeignKey("chats.id"), nullable=False) + sender_id = Column(String, ForeignKey("users.id"), nullable=False) + text = Column(Text, nullable=False) + created_at = Column(DateTime(timezone=True), nullable=False, default=now) + chat = relationship("Chat") + sender = relationship("User") + __table_args__ = (Index("ix_messages_chat_created_id", "chat_id", "created_at", "id"),) diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..c5605007 --- /dev/null +++ b/src/main.py @@ -0,0 +1,233 @@ +"""Lab 2 REST API: PostgreSQL-backed records and opaque bearer sessions.""" +import base64 +import binascii +import uuid +from datetime import timezone +from fastapi import FastAPI, Request, Query +from fastapi.responses import JSONResponse +from fastapi.exceptions import RequestValidationError +from sqlalchemy import text +from sqlalchemy.exc import SQLAlchemyError +from .database import SessionLocal +from .models import CreateUser, CreateChat, CreateMessage +from .store import store, cursor_for_chat, cursor_for_message +from . import session_cache + + +class AppError(Exception): + def __init__(self, status, code, message, headers=None): + self.status, self.code, self.message, self.headers = status, code, message, headers or {} + + +app = FastAPI(title="MTUSI Messenger", version="2.0.0") + + +@app.middleware("http") +async def request_headers(request: Request, call_next): + request.state.request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4()) + response = await call_next(request) + response.headers["X-Request-Id"] = request.state.request_id + return response + + +@app.exception_handler(AppError) +async def app_error_handler(request, exc): + headers = {"X-Request-Id": request.state.request_id, **exc.headers} + return JSONResponse(status_code=exc.status, content={"error":{"code":exc.code,"message":exc.message,"request_id":request.state.request_id}}, headers=headers) + + +@app.exception_handler(RequestValidationError) +async def validation_handler(request, exc): + return JSONResponse(status_code=400, content={"error":{"code":"invalid_request","message":"Invalid request","request_id":request.state.request_id}}, headers={"X-Request-Id":request.state.request_id}) + + +@app.exception_handler(SQLAlchemyError) +async def database_error_handler(request, exc): + return JSONResponse(status_code=503, content={"error":{"code":"unavailable","message":"Database unavailable","request_id":request.state.request_id}}, headers={"X-Request-Id":request.state.request_id}) + + +@app.exception_handler(Exception) +async def internal_handler(request, exc): + return JSONResponse(status_code=500, content={"error":{"code":"internal_error","message":"Internal server error","request_id":request.state.request_id}}, headers={"X-Request-Id":request.state.request_id}) + + +def stamp(value): + if value.tzinfo is None: + value = value.replace(tzinfo=timezone.utc) + return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z") + + +def user_json(user): + return {"id":user.id,"username":user.username,"display_name":user.display_name,"created_at":stamp(user.created_at)} + + +def auth_user(request): + header = request.headers.get("Authorization", "") + if not header.startswith("Bearer ") or not header[7:]: + raise AppError(401,"unauthorized","Authentication required",{"WWW-Authenticate":'Bearer realm="messenger"'}) + try: + found = store.get_session_by_token(header[7:]) + except session_cache.CacheUnavailable: + raise AppError(503,"unavailable","Session cache unavailable") + except SQLAlchemyError: + raise AppError(503,"unavailable","Authentication store unavailable") + if not found: + raise AppError(401,"unauthorized","Invalid or expired session",{"WWW-Authenticate":'Bearer realm="messenger"'}) + return found[0] + + +def chat_json(chat): + return {"id":chat.id,"title":chat.title,"member_ids":[m.user_id for m in chat.members],"created_at":stamp(chat.created_at)} + + +def validate_uuid(value): + try: + uuid.UUID(value) + except (ValueError, AttributeError): + raise AppError(400,"invalid_request","Invalid UUID") + + +@app.get("/health/live") +async def live(): + return {"status":"ok"} + + +@app.get("/health/ready") +async def ready(): + try: + with SessionLocal() as db: + db.execute(text("SELECT 1")) + session_cache.ping() + return {"status":"ok"} + except session_cache.CacheUnavailable: + raise AppError(503,"unavailable","Session cache unavailable") + except SQLAlchemyError: + raise AppError(503,"unavailable","Database unavailable") + + +@app.post("/api/v1/users", status_code=201) +async def register(data: CreateUser): + if not data.display_name.strip() or not 12 <= len(data.password) <= 128: + raise AppError(400,"invalid_request","Invalid user fields") + try: + return user_json(store.add_user(data.username,data.display_name,data.password)) + except ValueError as exc: + if str(exc) == "USERNAME_EXISTS": + raise AppError(409,"conflict","Username already exists") + raise AppError(400,"invalid_request","Invalid user fields") + except SQLAlchemyError: + raise AppError(503,"unavailable","Database unavailable") + + +@app.post("/api/v1/auth/sessions", status_code=201) +async def login(request: Request): + header = request.headers.get("Authorization", "") + challenge = {'WWW-Authenticate':'Basic realm="messenger", charset="UTF-8"'} + if not header.startswith("Basic "): + raise AppError(401,"unauthorized","Invalid credentials",challenge) + try: + decoded = base64.b64decode(header[6:], validate=True).decode("utf-8") + username, password = decoded.split(":", 1) + except (binascii.Error, UnicodeError, ValueError): + raise AppError(401,"unauthorized","Invalid credentials",challenge) + try: + user = store.verify_user_password(username,password) + if not user: + raise AppError(401,"unauthorized","Invalid credentials",challenge) + session = store.create_session(user.id) + return {"token":session.token,"token_type":"Bearer","expires_at":stamp(session.expires_at),"user":user_json(user)} + except session_cache.CacheUnavailable: + raise AppError(503,"unavailable","Session cache unavailable") + except SQLAlchemyError: + raise AppError(503,"unavailable","Database unavailable") + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def logout(request: Request): + auth_user(request) + try: + store.delete_session(request.headers["Authorization"][7:]) + except session_cache.CacheUnavailable: + raise AppError(503,"unavailable","Session cache unavailable") + except SQLAlchemyError: + raise AppError(503,"unavailable","Authentication store unavailable") + return None + + +@app.get("/api/v1/users/me") +async def me(request: Request): + user_id = auth_user(request) + user = store.get_user_by_id(user_id) + if not user: + raise AppError(401,"unauthorized","Invalid session",{'WWW-Authenticate':'Bearer realm="messenger"'}) + return user_json(user) + + +@app.post("/api/v1/chats", status_code=201) +async def create_chat(data: CreateChat, request: Request): + user_id = auth_user(request) + if not data.title.strip(): + raise AppError(400,"invalid_request","Invalid title") + try: + return chat_json(store.create_chat(data.title,data.member_ids,user_id)) + except ValueError as exc: + if str(exc)=="USER_NOT_FOUND": + raise AppError(400,"invalid_request","Unknown member") + raise AppError(400,"invalid_request","Invalid members") + except SQLAlchemyError: + raise AppError(503,"unavailable","Database unavailable") + + +@app.get("/api/v1/chats") +async def list_chats(request: Request, limit: int = Query(50,ge=1,le=100), cursor: str|None=None): + user_id=auth_user(request) + try: + rows=store.get_user_chats(user_id,cursor,limit+1) + except ValueError: + raise AppError(400,"invalid_request","Invalid cursor") + more=len(rows)>limit + rows=rows[:limit] + return {"items":[chat_json(c) for c in rows],"next_cursor":cursor_for_chat(rows[-1]) if more else None} + + +@app.get("/api/v1/chats/{chat_id}") +async def get_chat(chat_id: str, request: Request): + user_id=auth_user(request) + validate_uuid(chat_id) + if not store.is_chat_member(chat_id,user_id): + raise AppError(404,"not_found","Chat not found") + chat=store.get_chat(chat_id) + if not chat: + raise AppError(404,"not_found","Chat not found") + return chat_json(chat) + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +async def create_message(chat_id: str, data: CreateMessage, request: Request): + user_id=auth_user(request) + validate_uuid(chat_id) + if data.text is None or len(data.text)>4000 or not data.text.strip(): + raise AppError(400,"invalid_request","Invalid message text") + try: + msg=store.add_message(chat_id,user_id,data.text) + return {"id":msg.id,"chat_id":msg.chat_id,"sender_id":msg.sender_id,"text":msg.text,"created_at":stamp(msg.created_at)} + except ValueError: + raise AppError(404,"not_found","Chat not found") + except SQLAlchemyError: + raise AppError(503,"unavailable","Database unavailable") + + +@app.get("/api/v1/chats/{chat_id}/messages") +async def list_messages(chat_id: str, request: Request, limit: int=Query(50,ge=1,le=100), cursor: str|None=None): + user_id=auth_user(request) + validate_uuid(chat_id) + if not store.is_chat_member(chat_id,user_id): + raise AppError(404,"not_found","Chat not found") + try: + rows=store.get_messages(chat_id,cursor,limit+1) + except ValueError: + raise AppError(400,"invalid_request","Invalid cursor") + more=len(rows)>limit + rows=rows[:limit] + items=[{"id":m.id,"chat_id":m.chat_id,"sender_id":m.sender_id,"text":m.text,"created_at":stamp(m.created_at)} for m in rows] + return {"items":items,"next_cursor":cursor_for_message(rows[-1]) if more else None} diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..6194ac06 --- /dev/null +++ b/src/models.py @@ -0,0 +1,27 @@ +from pydantic import BaseModel, Field, ConfigDict +from typing import List + + +# ==================== REQUEST MODELS ==================== + +class CreateUser(BaseModel): + model_config = ConfigDict(extra="forbid", str_strip_whitespace=False) + username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(..., min_length=1, max_length=100) + password: str = Field(..., min_length=12, max_length=128) + + +class CreateChat(BaseModel): + model_config = ConfigDict(extra="forbid") + title: str = Field(..., min_length=1, max_length=100) + member_ids: List[str] = Field(..., min_length=1, max_length=100) + + +class CreateMessage(BaseModel): + model_config = ConfigDict(extra="forbid") + text: str = Field(..., min_length=1, max_length=4000) + + +class LoginRequest(BaseModel): + username: str + password: str 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..d459ea2e --- /dev/null +++ b/src/store.py @@ -0,0 +1,161 @@ +"""Small repository layer; each operation owns and closes its DB transaction.""" +import base64 +import json +import uuid +from datetime import datetime, timezone, timedelta +import math +from sqlalchemy import and_, or_ +from sqlalchemy.orm import selectinload +from sqlalchemy.exc import IntegrityError +from .database import User, Session as SessionRow, Chat, ChatMember, Message, SessionLocal +from .auth import hash_password, verify_password, new_token, SESSION_TTL_SECONDS +from . import session_cache + + +class Store: + def add_user(self, username, display_name, password): + with SessionLocal() as db: + user = User(username=username, display_name=display_name, password_hash=hash_password(password)) + db.add(user) + try: + db.commit() + except IntegrityError: + db.rollback() + raise ValueError("USERNAME_EXISTS") + db.refresh(user) + return user + + def get_user_by_id(self, user_id): + with SessionLocal() as db: + return db.query(User).filter(User.id == user_id).first() + + def verify_user_password(self, username, password): + with SessionLocal() as db: + user = db.query(User).filter(User.username == username).first() + # A fixed dummy hash is avoided here; the public contract only requires + # identical response status and challenge for unknown users/bad passwords. + if not user or not verify_password(password, user.password_hash): + return None + return user + + def create_session(self, user_id): + with SessionLocal() as db: + row = SessionRow(token=new_token(), user_id=user_id, + expires_at=datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS)) + db.add(row) + db.commit() + db.refresh(row) + try: + session_cache.put(row.token, row.user_id, SESSION_TTL_SECONDS) + except session_cache.CacheUnavailable: + db.delete(row) + db.commit() + raise + return row + + def get_session_by_token(self, token): + cached_user_id = session_cache.get(token) + if cached_user_id: + return (cached_user_id, None) + with SessionLocal() as db: + row = db.query(SessionRow).filter(SessionRow.token == token, + SessionRow.expires_at > datetime.now(timezone.utc)).first() + if not row: + return None + remaining = math.ceil((row.expires_at - datetime.now(timezone.utc)).total_seconds()) + session_cache.put(row.token, row.user_id, remaining) + return (row.user_id, row.expires_at) + + def delete_session(self, token): + # Require successful cache invalidation before reporting a completed logout. + session_cache.delete(token) + with SessionLocal() as db: + row = db.query(SessionRow).filter(SessionRow.token == token).first() + if row: + db.delete(row) + db.commit() + return True + return False + + def create_chat(self, title, member_ids, creator_id): + if creator_id not in member_ids: + raise ValueError("CREATOR_NOT_MEMBER") + if len(member_ids) != len(set(member_ids)): + raise ValueError("DUPLICATE_MEMBER") + with SessionLocal() as db: + users = db.query(User.id).filter(User.id.in_(member_ids)).all() + if len(users) != len(member_ids): + raise ValueError("USER_NOT_FOUND") + chat = Chat(title=title) + chat.members = [ChatMember(user_id=mid) for mid in member_ids] + db.add(chat) + db.commit() + db.refresh(chat) + list(chat.members) + return chat + + def get_chat(self, chat_id): + with SessionLocal() as db: + return db.query(Chat).options(selectinload(Chat.members)).filter(Chat.id == chat_id).first() + + def get_user_chats(self, user_id, cursor=None, limit=50): + with SessionLocal() as db: + query = db.query(Chat).options(selectinload(Chat.members)).join(ChatMember).filter(ChatMember.user_id == user_id) + if cursor: + decoded = decode_cursor(cursor, "chats") + query = query.filter(or_(Chat.created_at > decoded[0], and_(Chat.created_at == decoded[0], Chat.id > decoded[1]))) + rows = query.order_by(Chat.created_at, Chat.id).limit(limit).all() + for row in rows: + list(row.members) + return rows + + def is_chat_member(self, chat_id, user_id): + with SessionLocal() as db: + return db.query(ChatMember.id).filter(ChatMember.chat_id == chat_id, ChatMember.user_id == user_id).first() is not None + + def add_message(self, chat_id, sender_id, text): + with SessionLocal() as db: + if not db.query(Chat.id).filter(Chat.id == chat_id).first(): + raise ValueError("CHAT_NOT_FOUND") + if not db.query(ChatMember.id).filter(ChatMember.chat_id == chat_id, ChatMember.user_id == sender_id).first(): + raise ValueError("NOT_MEMBER") + msg = Message(chat_id=chat_id, sender_id=sender_id, text=text) + db.add(msg) + db.commit() + db.refresh(msg) + return msg + + def get_messages(self, chat_id, cursor=None, limit=50): + with SessionLocal() as db: + query = db.query(Message).filter(Message.chat_id == chat_id) + if cursor: + created, message_id = decode_cursor(cursor, chat_id) + query = query.filter(or_(Message.created_at > created, + and_(Message.created_at == created, Message.id > message_id))) + return query.order_by(Message.created_at, Message.id).limit(limit).all() + + +def encode_cursor(resource, created_at, item_id): + raw = json.dumps([resource, created_at.isoformat(), item_id], separators=(",", ":")).encode() + return base64.urlsafe_b64encode(raw).decode().rstrip("=") + + +def decode_cursor(cursor, resource): + try: + data = json.loads(base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4))) + if data[0] != resource: + raise ValueError + return datetime.fromisoformat(data[1]), data[2] + except Exception: + raise ValueError("INVALID_CURSOR") + + +def cursor_for_chat(chat): + return encode_cursor("chats", chat.created_at, chat.id) + + +def cursor_for_message(message): + return encode_cursor(message.chat_id, message.created_at, message.id) + + +store = Store() diff --git a/tests/README.md b/tests/README.md index 0dfa3f89..4302bee5 100644 --- a/tests/README.md +++ b/tests/README.md @@ -24,6 +24,16 @@ make test-persistence ACTION_SCRIPT=scripts/restart.sh Тест создаёт данные и сессию, запускает указанный файл без shell interpolation, ожидает готовности и проверяет те же данные **с прежним токеном**. В lab4+ также проверяется исходный файл. Hook может работать до 90 секунд, готовность затем ожидается до 90 секунд. TTL сессии для этого теста — минимум 300 секунд. Успех не доказывает, что hook действительно перезапустил БД: приложите команды/состояния контейнеров до и после. +## Дополнительные проверки уровня 4, lab2 + +Стенд должен быть запущен через Compose с Redis, а локальный `.env` — содержать корректные настройки. Проверка управляет только сервисами `redis`, `db` и `api` этой Compose-группы; Docker volume не удаляется. Используются уникальные синтетические пользователи и чат, а индексный сценарий добавляет 12 000 синтетических сообщений в PostgreSQL. Эти fixtures остаются в стенде для возможности осмотра. + +```sh +make test-level4 BASE_URL=http://localhost:8080 +``` + +Сценарий автоматически проверяет гонку двух одинаковых регистраций, отсутствие частичного чата при ошибке состава участников, наличие ключей сессий в Redis, неверный пароль, logout, истечение сессии при TTL=2 секунды, поведение API при остановке Redis и PostgreSQL, восстановление существующей сессии после restart Redis, а также `EXPLAIN (ANALYZE, BUFFERS)` keyset-запроса на 12 000 строк. Во время короткого TTL сценария скрипт временно меняет `SESSION_TTL_SECONDS` в локальном `.env`, перезапускает API и восстанавливает исходный файл даже при ошибке теста. План сохраняется в `evidence/history-plan.txt`. + ## Проверка отказа, lab3+ Реализуйте `scripts/stop-one.sh` на основе примера. `TARGET_INSTANCE_ID` в окружении содержит alias обслужившей тест API-реплики: сопоставьте его своему контейнеру/Swarm task и остановите именно его. Скрипт должен быстро вернуть 0 и **оставить эту реплику остановленной**; восстановление выполняйте отдельно. Swarm может создать новую task с другим ID — это допустимо. diff --git a/tests/level4.py b/tests/level4.py new file mode 100644 index 00000000..8195fe83 --- /dev/null +++ b/tests/level4.py @@ -0,0 +1,228 @@ +#!/usr/bin/env python3 +"""Automated lab 2 level-4 checks; operates only on synthetic test records.""" +import base64 +import concurrent.futures +import json +import os +from pathlib import Path +import subprocess +import time +import urllib.error +import urllib.request +import uuid + +from client import Client, Failure, arguments, check, run + +ROOT = Path(__file__).resolve().parents[1] +ENV_FILE = ROOT / '.env' + + +def compose(*args, check_ok=True): + result = subprocess.run(['docker', 'compose', '--env-file', '.env', *args], + cwd=ROOT, capture_output=True, text=True) + if check_ok and result.returncode: + raise Failure('docker compose operation failed: ' + ' '.join(args)) + return result + + +def wait_ready(client, timeout=90): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + try: + client.call('GET', '/health/ready', schema='Health') + return + except Failure: + time.sleep(0.5) + raise Failure('API did not recover within the readiness deadline') + + +def parse_env(raw): + result = {} + for line in raw.decode('ascii').splitlines(): + if '=' in line and not line.lstrip().startswith('#'): + key, value = line.split('=', 1) + result[key] = value + return result + + +def write_env(values): + ENV_FILE.write_text(''.join(f'{key}={value}\n' for key, value in values.items()), encoding='ascii') + + +def registration_race(client): + username = 'race_' + uuid.uuid4().hex[:16] + body = {'username': username, 'display_name': 'Concurrent synthetic user', + 'password': 'Race-Pass-' + uuid.uuid4().hex} + + def post_once(): + request = urllib.request.Request(client.base + '/api/v1/users', + data=json.dumps(body).encode('utf-8'), + headers={'Content-Type': 'application/json'}, method='POST') + opener = urllib.request.build_opener() + try: + response = opener.open(request, timeout=10) + except urllib.error.HTTPError as error: + response = error + with response: + return response.status + + with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor: + statuses = sorted(executor.map(lambda _: post_once(), range(2))) + check(statuses == [201, 409], 'concurrent duplicate registration was not serialized') + + +def list_all_chats(client, actor): + path = '/api/v1/chats?limit=100' + rows = [] + while True: + page = client.call('GET', path, actor=actor, schema='ChatPage')['json'] + rows.extend(page['items']) + if page['next_cursor'] is None: + return rows + from urllib.parse import quote + path = '/api/v1/chats?limit=100&cursor=' + quote(page['next_cursor'], safe='') + + +def database_sql(sql, variables=None): + values = parse_env(ENV_FILE.read_bytes()) + args = ['docker', 'compose', '--env-file', '.env', 'exec', '-T', 'db', + 'psql', '-U', values['POSTGRES_USER'], '-d', values['POSTGRES_DB'], + '-v', 'ON_ERROR_STOP=1'] + for name, value in (variables or {}).items(): + args.extend(['-v', name + '=' + value]) + result = subprocess.run(args, cwd=ROOT, input=sql, capture_output=True, text=True) + if result.returncode: + raise Failure('database verification query failed') + return result.stdout + + +def internal_status(path, token=None): + # During an unhealthy dependency state Docker Desktop may stop forwarding + # the published host port. Probe the API loopback from its own container. + code = """ +import os, sys, urllib.request, urllib.error +request = urllib.request.Request('http://127.0.0.1:8080' + sys.argv[1]) +token = os.getenv('CHECK_TOKEN') +if token: + request.add_header('Authorization', 'Bearer ' + token) +try: + response = urllib.request.urlopen(request, timeout=30) + print(response.status) +except urllib.error.HTTPError as error: + print(error.code) +""" + command = ['docker', 'compose', '--env-file', '.env', 'exec', '-T'] + if token: + command.extend(['-e', 'CHECK_TOKEN=' + token]) + command.extend(['api', 'python', '-', path]) + result = subprocess.run(command, cwd=ROOT, input=code, capture_output=True, text=True, timeout=32) + if result.returncode: + raise Failure('in-container dependency probe failed: ' + result.stderr[-500:]) + return int(result.stdout.strip().splitlines()[-1]) + + +def check_index_plan(client, actor): + chat = client.call('POST', '/api/v1/chats', 201, actor=actor, + body={'title': 'synthetic index plan', 'member_ids': [actor['id']]}, schema='Chat')['json'] + seed_sql = """ +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid()::text, :'chat_id', :'sender_id', 'plan-probe-' || n, + CURRENT_TIMESTAMP - interval '12000 seconds' + n * interval '1 second' +FROM generate_series(1, 12000) AS n; +ANALYZE messages; +SELECT count(*) FROM messages WHERE chat_id = :'chat_id'; +""" + seeded = database_sql(seed_sql, {'chat_id': chat['id'], 'sender_id': actor['id']}) + check('12000' in {line.strip() for line in seeded.splitlines()}, + 'expected 12,000 synthetic history rows') + plan_sql = """ +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, created_at FROM messages +WHERE chat_id = :'chat_id' + AND (created_at, id) > (CURRENT_TIMESTAMP - interval '6000 seconds', '') +ORDER BY created_at, id +LIMIT 50; +""" + plan = database_sql(plan_sql, {'chat_id': chat['id']}) + check('ix_messages_chat_created_id' in plan, 'keyset history plan did not use the composite index') + evidence = ROOT / 'evidence' / 'history-plan.txt' + evidence.write_text('Synthetic chat rows: 12000\nQuery: keyset range on (created_at, id), LIMIT 50\n\n' + plan, + encoding='utf-8') + page = client.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=50', + actor=actor, schema='MessagePage')['json'] + check(len(page['items']) == 50 and page['next_cursor'], 'keyset history did not return a next page') + + +def check_dependency_failures(client, actor): + compose('stop', 'redis') + try: + check(internal_status('/health/ready') == 503, 'readiness did not fail when Redis was down') + check(internal_status('/api/v1/chats', actor['token']) == 503, + 'authenticated request did not fail in a bounded way when Redis was down') + finally: + compose('start', 'redis') + wait_ready(client) + # Redis AOF plus PostgreSQL source of truth must preserve/rebuild this session. + client.call('GET', '/api/v1/users/me', actor=actor, schema='User') + + compose('stop', 'db') + try: + check(internal_status('/health/ready') == 503, 'readiness did not fail when PostgreSQL was down') + check(internal_status('/api/v1/chats', actor['token']) == 503, + 'authenticated request did not fail when PostgreSQL was down') + finally: + compose('start', 'db') + wait_ready(client) + client.call('GET', '/api/v1/users/me', actor=actor, schema='User') + + +def check_short_ttl(client): + saved_env = ENV_FILE.read_bytes() + values = parse_env(saved_env) + try: + values['SESSION_TTL_SECONDS'] = '2' + write_env(values) + compose('up', '-d', '--force-recreate', 'api') + wait_ready(client) + actor = client.user('expiry') + time.sleep(3) + client.call('GET', '/api/v1/users/me', 401, actor=actor) + finally: + ENV_FILE.write_bytes(saved_env) + compose('up', '-d', '--force-recreate', 'api') + wait_ready(client) + + +def main(): + args = arguments('Lab 2 level-4 concurrency, rollback, expiry, failure, and index checks') + client = Client(args.base_url, args.ca_file, timeout=5) + wait_ready(client) + alice, bob, _eve, chat = client.bootstrap() + + bad = base64.b64encode((alice['registration']['username'] + ':wrong-password').encode()).decode() + client.call('POST', '/api/v1/auth/sessions', 401, + headers={'Authorization': 'Basic ' + bad}) + + registration_race(client) + before = {item['id'] for item in list_all_chats(client, alice)} + client.call('POST', '/api/v1/chats', 400, actor=alice, + body={'title': 'must rollback', 'member_ids': [alice['id'], str(uuid.uuid4())]}) + after = {item['id'] for item in list_all_chats(client, alice)} + check(before == after, 'failed multi-row chat creation left a partial chat') + + cache_size = compose('exec', '-T', 'redis', 'redis-cli', 'DBSIZE').stdout.strip() + check(cache_size.isdigit() and int(cache_size) > 0, 'Redis does not contain active session keys') + check_dependency_failures(client, bob) + check_index_plan(client, alice) + + logout_actor = client.user('logout') + client.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=logout_actor) + client.call('GET', '/api/v1/users/me', 401, actor=logout_actor) + + check_short_ttl(client) + print('PASS: level-4 Redis TTL/recovery, dependency failures, expiry/logout/bad password, ' + 'registration race, chat rollback, and indexed 12,000-row history.') + + +if __name__ == '__main__': + run(main)