diff --git a/.env.example b/.env.example index 714c8076..81be354a 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,4 @@ -# 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 +POSTGRES_DB=messenger +POSTGRES_USER=messenger +POSTGRES_PASSWORD=replace-with-your-local-password 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 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..4f19c50e --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +*.py text eol=lf +*.sh text eol=lf +*.cmd text eol=crlf +*.yaml text eol=lf +*.sql text eol=lf diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..43c768b0 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,29 @@ +FROM python:3.14.8-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 \ + APP_ENV=lab + +WORKDIR /app +COPY requirements.txt ./ +RUN python -m pip install --no-cache-dir -r requirements.txt +RUN groupadd --gid 10001 appuser \ + && useradd --uid 10001 --gid appuser --no-create-home --shell /usr/sbin/nologin appuser + +COPY src ./src +COPY migrations ./migrations +COPY tests ./tests +COPY student-tests ./student-tests +COPY scripts ./scripts +COPY contracts ./contracts +COPY lab.json ./ + +USER 10001:10001 +EXPOSE 8080 +STOPSIGNAL SIGTERM +HEALTHCHECK --interval=5s --timeout=3s --start-period=5s --retries=3 \ + CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:'+os.getenv('APP_PORT','8080')+'/health/ready', timeout=2).close()"] + +CMD ["python", "-m", "src.run"] diff --git a/REPORT.md b/REPORT.md index e42f2b05..ab425338 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,219 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Рестеу Даниил Андреевич, БВТ2302. +- Целевая оценка: 4. Трек уровня 5 не выполнялся. +- Commit/PR: вписать ссылку после публикации в своём fork. +- Использованные источники, библиотеки и помощь ИИ: собственный API лабораторной 1; + FastAPI, Pydantic, Psycopg 3/psycopg-pool, argon2-cffi, redis-py, Uvicorn; + документация PostgreSQL, Redis, Psycopg, Docker и RFC 7617/6750. + ChatGPT/Codex использован для доработки реализации, проверки требований, + тестов, ревью и подготовки объяснения кода. Это отмечается как помощь ИИ, + а не как полностью самостоятельное написание всех строк. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Необходимы Docker с Compose v2 и Python 3.9+ для публичных скриптов на хосте. +В Dockerfile закреплён `python:3.14.8-slim-bookworm`, в Compose — +`postgres:17.11-bookworm` и `redis:8.2.10-bookworm`. Зависимости Python +перечислены в requirements.txt с точными версиями. + +На чистом стенде скопировать .env.example в .env и задать локальный учебный +POSTGRES_PASSWORD. Если данные PostgreSQL уже существуют, использовать +прежние настройки .env: изменение переменной само не меняет пароль в БД. + +PowerShell: + +```powershell +Copy-Item .env.example .env +# Здесь задать свой POSTGRES_PASSWORD в .env, если стенд создаётся впервые. +docker compose config --quiet +docker compose up -d --build --wait api +Invoke-RestMethod http://localhost:8080/health/ready +python scripts/check_contract.py +docker compose exec -T api python tests/smoke.py +docker compose exec -T api python -m unittest discover -s student-tests -v +docker compose exec -T api python scripts/explain_history.py +python scripts/check_grade4.py --base-url http://127.0.0.1:8080 +python tests/resilience.py --mode persistence --action-script scripts/restart.cmd +``` + +Для уже существующего стенда строку Copy-Item пропустить, сохранив .env. + +Linux: + +```sh +cp .env.example .env +# Задать локальный POSTGRES_PASSWORD. +docker compose config --quiet +docker compose up -d --build --wait api +make check +make test +docker compose exec -T api python -m unittest discover -s student-tests -v +docker compose exec -T api python scripts/explain_history.py +python3 scripts/check_grade4.py +chmod +x scripts/restart.sh +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` + +Мигратор автоматически запускается перед api. Для отдельного повторного +запуска: `docker compose run --rm migrate`. Уже применённые файлы получают SKIP. + +Обычная остановка: `docker compose down` — volumes сохраняются. +Намеренное удаление всех учебных данных: `docker compose down -v`. +В .gitignore/.dockerignore исключены .env, закрытые ключи и локальные данные. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент обращается к api. PostgreSQL — источник истины для users, chats, +chat_members и messages. Redis — единственный источник истины для сессий. +Кэширование истории не используется; чтения идут в основную БД. + +Из lab1 перенесены API, валидация, формат ошибок, request ID, health endpoints, +Docker-запуск и собственные HTTP-тесты. MemoryStore удалён. X-User-Id игнорируется. + +Basic используется только для POST /api/v1/auth/sessions. Пароли 12–128 code points +хешируются Argon2id. Оpaque Bearer token генерируется из 32 случайных байт. +Redis хранит UUID владельца под session: с абсолютным PXAT. TTL по +умолчанию 3600 секунд, задаётся SESSION_TTL_SECONDS. Logout удаляет ключ. +AOF с appendfsync always и volume redis_data сохраняет действующие сессии и +отзыв; рестарт не продлевает срок. FLUSHALL уничтожит сессии, но не доменные данные. + +Таблицы имеют UUID PK, FK и UNIQUE username. Составной PK (chat_id,user_id) +предотвращает дубли членства. 01_initial.sql создаёт схему, 02_chat_order.sql +добавляет индекс списка чатов. schema_migrations предотвращает повторное +применение. Создание чата и всех его участников выполняется в одной транзакции; +ошибка FK неизвестного участника откатывает весь чат. + +SQL параметризован. Пул одного api-процесса содержит 1–5 соединений, очередь +ожидающих ограничена 20. Ожидание пула — 3 с, подключение — 5 с, +statement_timeout — 5000 мс, lock_timeout — 3000 мс. Redis имеет socket/connect +timeouts по 2 с и не делает автоматические retry. При отказах защищённые +операции возвращают 503 в общем формате. /health/live не зависит от хранилищ; +/health/ready проверяет PostgreSQL и Redis, обе зависимости критичны. + +История сортируется по (created_at,id) ASC. SQL получает максимум limit+1 строк +через ключевую границу; полного чтения/сортировки истории в Python нет. +Cursor содержит область запроса, UTC timestamp и UUID. Для неизменной истории +повторов нет, изменение limit допускается. Общего snapshot между страницами нет: +конкурентная запись с уже пройденным временем может быть пропущена этим обходом. +Часы БД должны быть корректны. Подтверждённая запись видна следующему чтению. + +POSTGRES_DB/USER/PASSWORD и SESSION_TTL_SECONDS из .env.example действительно +используются Compose и приложением. Внутренние адреса — postgres:5432 и +redis:6379, наружу опубликован только api на 127.0.0.1:8080. +POSTGRES_HOST/PORT и REDIS_HOST/PORT дополнительно можно переопределить +для локальной проверки без Docker. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +Итоговый прогон выполнен 19.10.2026 на Windows в PowerShell с Docker Desktop. +Приложение собрано из python:3.14.8-slim-bookworm, PostgreSQL — +17.11-bookworm, Redis — 8.2.10-bookworm. Публичный smoke, все 16 собственных +тестов, короткий TTL, отказы обоих хранилищ и полный persistence-сценарий +завершились успешно. Публичные tests/, contracts/, Makefile и README.md +по содержимому не изменены. -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +evidence/windows-api.txt — предоставленный исходный вывод PowerShell со +сборкой, smoke и 16 тестами. evidence/windows-summary.md — сводка остальных +предоставленных результатов; это не полный необработанный журнал всех команд. +evidence/grade4-windows.txt содержит вывод проверки TTL/отказов. + +Файлы с native-результатами относятся к отдельному предварительному прогону +на Python 3.12.14 / PostgreSQL 16.15 / Redis 7.0.15. Его версии и параметры +оборудования не являются характеристиками компьютера студента. + +| Критерий README | Команда/сценарий | Наблюдаемый результат локальной проверки | Файл доказательства | +| --- | --- | --- | --- | +| Структура контракта | python scripts/check_contract.py | PASS на Windows | evidence/windows-summary.md | +| Синтаксис Compose и сборка | docker compose config --quiet; up -d --build --wait api | конфигурация принята, образы собраны, api/postgres/redis healthy | evidence/windows-api.txt | +| Публичный API | docker compose exec -T api python tests/smoke.py | PASS lab2 на Windows/Docker | evidence/windows-api.txt | +| Миграции с нуля | python -m src.migrate на новой БД предварительного native-стенда | APPLIED обе миграции; этот лог относится к native-прогону | evidence/migrations.txt | +| Повтор миграций | повтор python -m src.migrate на native-стенде | SKIP обе миграции | evidence/migrations-repeat.txt | +| Сохранены проверки API lab1 | docker compose exec -T api python -m unittest discover -s student-tests -v | 16 тестов OK, 5.909 с на Windows/Docker | evidence/windows-api.txt | +| Безопасные запросы, конкурентная регистрация | test_registration_race | тест OK: один 201, три 409; в БД одна строка | evidence/windows-api.txt | +| Атомарное создание чата | test_chat_rollback_after_unknown_member | тест OK: 400; нет частичного чата и членства | evidence/windows-api.txt | +| KDF, UTF-8 пароль с двоеточием, 256 бит токена | test_unicode_password_with_colon_and_hash | тест OK: вход успешен, Argon2id в БД, 32 случайных байта токена | evidence/windows-api.txt | +| Bearer, неправильный пароль, logout, X-User-Id | smoke и test_login_logout_and_legacy_header | smoke PASS и тест OK на Windows/Docker | evidence/windows-api.txt | +| Expiry в Redis при TTL=2 | python scripts/check_grade4.py --base-url http://127.0.0.1:8080 | PASS: активный токен после истечения получает 401 | evidence/grade4-windows.txt | +| Отказы Redis и БД | тот же scripts/check_grade4.py | оба PASS: bounded 503, live=200, anonymous=401; старый токен работает после восстановления | evidence/grade4-windows.txt | +| Сохранность после полного рестарта | python tests/resilience.py --mode persistence --action-script scripts/restart.cmd | PASS: confirmed data и прежняя сессия сохранились | evidence/windows-summary.md | +| Область фактического native restart hook | PID api, postgres, redis до/после | все три процесса заменены | evidence/native-restart-processes.json | +| Индекс на >=10000 сообщениях | docker compose exec -T api python scripts/explain_history.py | PostgreSQL 17.11, 10000 сообщений; обе страницы используют messages_history_idx | evidence/windows-summary.md | +| Собственные негативные проверки | cursor scope/time, NUL, строгие поля, чужой чат | соответствующие тесты OK на Windows/Docker | evidence/windows-api.txt | +| Фактический Compose restart hook | restart.cmd вызывает restart.py в persistence-тесте | сценарий PASS; hook записывает service/ID/StartedAt/status до и после | evidence/restart-before.txt, evidence/restart-after.txt | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Среда предварительного прогона: x86_64, 9 видимых CPU, cgroup RAM limit 8 GiB. +У контейнеров Compose отдельные CPU/RAM limits не назначены. Конкурентный +тест: 10 HTTP-клиентов, по 10 последовательных отправок; прочитаны все 100 +уникальных сообщений, ID и тексты совпали. В предварительном native-прогоне 16 тестов заняли 5.023 с; +на Windows/Docker — 5.909 с. Параметры CPU/RAM компьютера студента не фиксировались. +Это проверка корректности, не измерение максимальной производительности; +RPS, p50/p95/p99 и CPU/RAM под нагрузкой не измерялись и не заявляются. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +EXPLAIN использует 10000 синтетических сообщений одного чата в транзакции с +принудительным rollback. После измерения фикстуры не сохраняются. Выполняется +ANALYZE и затем EXPLAIN (ANALYZE, BUFFERS) тех же SQL-констант, которые использует +API. LIMIT 51 соответствует странице 50 + одной строке для next_cursor. +Для выбора тестовой границы после 9000-й строки используется OFFSET только +при подготовке эксперимента; запрос страницы использует keyset. + +В итоговом Windows/Docker-прогоне на PostgreSQL 17.11 первая страница имела +Execution Time 0.031 мс и 4 shared buffer hits; страница после 9000-й записи — +0.056 мс и 3 hits. Обе читали 51 строку через Index Scan messages_history_idx. +Это один локальный прогон с прогретыми данными, а не универсальный SLA. + +После замены адреса тестового API с localhost на 127.0.0.1 проверка короткой +сессии на Windows завершилась успешно. Значение TTL осталось равным 2 секундам. +Из одного первоначального 401 нельзя однозначно установить причину задержки. + +| Воздействие | Что ожидаем | Что наблюдали | Восстановление / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Истечение TTL=2 с | токен больше не принимается | 200 до ожидания, 401 после 2.2 с | повторный вход нужен | +| Logout | немедленный отзыв | 204, затем GET/DELETE с тем же токеном 401 | повторный вход нужен | +| Остановка Redis | безопасный отказ | 503; live=200; анонимный GET=401 | после старта старый действующий токен работает | +| Остановка PostgreSQL | безопасный отказ | 503; live=200; анонимный GET=401 | пул восстанавливается, старый токен работает | +| Перезапуск api и обоих хранилищ | данные и сессия сохраняются | публичный persistence PASS | исходное подтверждённое сообщение не потеряно | +| Неизвестный участник после INSERT чата | rollback всей операции | 400; частичных строк нет | состояние БД не изменилось | + +Native restart проверял реальные процессы предварительного стенда. +Итоговый Windows persistence-тест вызвал Docker hook через restart.cmd; +он перезапускает api, postgres и redis с сохранением volumes. Для проверки +области рестарта приложены restart-before.txt и restart-after.txt со StartedAt. +Времена полного восстановления отдельно не измерялись: тесты подтвердили +восстановление в пределах своих ожиданий, а не обещание конкретного SLA. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Один api, PostgreSQL и Redis на одном узле; высокой доступности и резервного +копирования нет. Volumes и AOF выдерживают проверяемый рестарт, но не заменяют +backup при удалении данных, потере диска или аппаратном сбое. Гарантии COMMIT +зависят от настроек PostgreSQL, fsync и реального диска; они не отключались. +Redis appendfsync always выбран ради durability, цена — дополнительные fsync. + +HTTP и синтетические credentials предназначены для локального стенда; удалённая +демонстрация требует TLS согласно заданию. История не кэшируется, поэтому +отсутствует задача инвалидации кэша сообщений. После потери Redis-сессий нужен +повторный вход. В текущем API нет удаления пользователей/членства и редактирования +сообщений. Между HTTP-страницами не поддерживается snapshot. + +Публичные тесты проверяют схему WWW-Authenticate; отдельные собственные assertions +на точное значение realm не добавлялись. Заголовки задаются явно в error_response. + +Закреплённые Docker-версии проверены на Windows. Перед сдачей остаётся +вписать ссылку commit/PR после публикации и подготовиться объяснить код. + +## Первичные источники + +- https://www.postgresql.org/docs/17/tutorial-transactions.html +- https://www.postgresql.org/docs/17/indexes-multicolumn.html +- https://www.postgresql.org/docs/17/using-explain.html +- https://www.psycopg.org/psycopg3/docs/basic/transactions.html +- https://www.psycopg.org/psycopg3/docs/advanced/pool.html +- https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/ +- https://redis.io/docs/latest/commands/set/ +- https://argon2-cffi.readthedocs.io/en/stable/howto.html +- https://www.rfc-editor.org/rfc/rfc7617 +- https://www.rfc-editor.org/rfc/rfc6750 +- https://docs.docker.com/reference/cli/docker/compose/up/ diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..ef475d29 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,57 @@ +services: + postgres: + image: postgres:17.11-bookworm + environment: + POSTGRES_DB: ${POSTGRES_DB:?Set POSTGRES_DB in .env} + POSTGRES_USER: ${POSTGRES_USER:?Set POSTGRES_USER in .env} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env} + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"] + interval: 5s + timeout: 3s + retries: 10 + + redis: + image: redis:8.2.10-bookworm + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"] + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + + migrate: + build: . + command: ["python", "-m", "src.migrate"] + environment: &database_settings + POSTGRES_DB: ${POSTGRES_DB} + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + depends_on: + postgres: + condition: service_healthy + healthcheck: + disable: true + + api: + build: . + environment: + <<: *database_settings + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + ports: + - "127.0.0.1:8080:8080" + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + migrate: + condition: service_completed_successfully + +volumes: + postgres_data: + redis_data: diff --git a/evidence/ENVIRONMENT.md b/evidence/ENVIRONMENT.md new file mode 100644 index 00000000..bcc73cb7 --- /dev/null +++ b/evidence/ENVIRONMENT.md @@ -0,0 +1,19 @@ +# Среда и область проверки + +Дата: 19.10.2026. Приложенные логи относятся к предварительному native-прогону, +а не к Docker Desktop студента. + +- Python 3.12.14, PostgreSQL 16.15, Redis 7.0.15, x86_64. +- 9 видимых CPU, cgroup RAM limit 8 GiB. +- Использовались настоящие PostgreSQL и Redis, не моки хранилищ. +- tests/smoke.py и tests/resilience.py запускались без изменений. +- Все 16 student-tests прошли; итоговый прогон — 5.023 с. +- EXPLAIN выполнен на 10000 временных сообщениях; обе страницы используют индекс. +- Короткий TTL, остановка каждого хранилища и полный рестарт реальных процессов прошли. +- native-restart-processes.json фиксирует PID api/postgres/redis до/после полного рестарта. +- Compose CLI 2.40.3 проверил compose.yaml командой config --quiet, код завершения 0. +- Docker daemon отсутствует. Docker build/up, закреплённые версии образов, + Windows restart.cmd и Docker restart.sh здесь не запускались. + +На компьютере студента нужно повторить команды START_HERE_RU.md, сохранить вывод +в отдельные файлы и обновить REPORT.md. Эти результаты не гарантируют оценку. diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 00000000..b3ab9dfa --- /dev/null +++ b/evidence/check.txt @@ -0,0 +1,2 @@ +.venv/bin/python scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. diff --git a/evidence/compose-config.txt b/evidence/compose-config.txt new file mode 100644 index 00000000..4bf68224 --- /dev/null +++ b/evidence/compose-config.txt @@ -0,0 +1,5 @@ +Compose CLI version: 2.40.3 +Command: docker compose config --quiet +Result: exit 0, no validation output +Synthetic environment supplied for POSTGRES_DB/USER/PASSWORD. +Docker daemon/build/up were not tested in this environment. diff --git a/evidence/explain-history.txt b/evidence/explain-history.txt new file mode 100644 index 00000000..c21a20a9 --- /dev/null +++ b/evidence/explain-history.txt @@ -0,0 +1,21 @@ +PostgreSQL 16.15 (Ubuntu 16.15-0ubuntu0.24.04.1) on x86_64-pc-linux-gnu, compiled by gcc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0, 64-bit +Fixture messages: 10000 +FIRST PAGE: LIMIT 51 (50 items + lookahead) +Limit (cost=0.29..5.65 rows=51 width=76) (actual time=0.006..0.012 rows=51 loops=1) + Buffers: shared hit=3 + -> Index Scan using messages_history_idx on messages (cost=0.29..1052.02 rows=10000 width=76) (actual time=0.005..0.009 rows=51 loops=1) + Index Cond: (chat_id = '799a61aa-3fa2-4535-84e9-28889941c357'::uuid) + Buffers: shared hit=3 +Planning: + Buffers: shared hit=18 +Planning Time: 0.046 ms +Execution Time: 0.018 ms +LATER PAGE: after message 9000, LIMIT 51 +Limit (cost=0.29..17.73 rows=51 width=76) (actual time=0.004..0.012 rows=51 loops=1) + Buffers: shared hit=4 + -> Index Scan using messages_history_idx on messages (cost=0.29..375.19 rows=1096 width=76) (actual time=0.003..0.008 rows=51 loops=1) + Index Cond: ((chat_id = '799a61aa-3fa2-4535-84e9-28889941c357'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:00.009+00'::timestamp with time zone, 'a598e58f-565a-4ff7-b30b-19dcc8524574'::uuid))) + Buffers: shared hit=4 +Planning Time: 0.035 ms +Execution Time: 0.024 ms +PASS: 10000 messages; first/later pages use messages_history_idx; fixtures rolled back diff --git a/evidence/grade4-native.txt b/evidence/grade4-native.txt new file mode 100644 index 00000000..863f9a1d --- /dev/null +++ b/evidence/grade4-native.txt @@ -0,0 +1,3 @@ +PASS: SESSION_TTL_SECONDS=2; active token becomes 401 after expiry +PASS: redis outage -> bounded 503; live=200; anonymous=401; old token recovers +PASS: postgres outage -> bounded 503; live=200; anonymous=401; old token recovers diff --git a/evidence/grade4-windows.txt b/evidence/grade4-windows.txt new file mode 100644 index 00000000..863f9a1d --- /dev/null +++ b/evidence/grade4-windows.txt @@ -0,0 +1,3 @@ +PASS: SESSION_TTL_SECONDS=2; active token becomes 401 after expiry +PASS: redis outage -> bounded 503; live=200; anonymous=401; old token recovers +PASS: postgres outage -> bounded 503; live=200; anonymous=401; old token recovers diff --git a/evidence/migrations-repeat.txt b/evidence/migrations-repeat.txt new file mode 100644 index 00000000..eb334732 --- /dev/null +++ b/evidence/migrations-repeat.txt @@ -0,0 +1,2 @@ +SKIP 01_initial.sql +SKIP 02_chat_order.sql diff --git a/evidence/migrations.txt b/evidence/migrations.txt new file mode 100644 index 00000000..354f123c --- /dev/null +++ b/evidence/migrations.txt @@ -0,0 +1,2 @@ +APPLIED 01_initial.sql +APPLIED 02_chat_order.sql diff --git a/evidence/native-restart-processes.json b/evidence/native-restart-processes.json new file mode 100644 index 00000000..135af217 --- /dev/null +++ b/evidence/native-restart-processes.json @@ -0,0 +1,30 @@ +{ + "before": { + "api": { + "pid": 24, + "running": true + }, + "postgres": { + "pid": 3775, + "running": true + }, + "redis": { + "pid": 3674, + "running": true + } + }, + "after": { + "api": { + "pid": 4090, + "running": true + }, + "postgres": { + "pid": 4077, + "running": true + }, + "redis": { + "pid": 4084, + "running": true + } + } +} \ No newline at end of file diff --git a/evidence/persistence-native.txt b/evidence/persistence-native.txt new file mode 100644 index 00000000..749fd29b --- /dev/null +++ b/evidence/persistence-native.txt @@ -0,0 +1,2 @@ +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/restart-after.txt b/evidence/restart-after.txt new file mode 100644 index 00000000..082b3813 --- /dev/null +++ b/evidence/restart-after.txt @@ -0,0 +1,3 @@ +api dafaccaefd42497d456f3e26d23ac6be4f70f0e37949c138328d0c97295311b3 2026-10-19T20:18:14.844180844Z running +postgres 9c96af6664fb6aae298d6153c6ecca2d88260d0e45c6e04f9642b45c669db5fb 2026-10-19T20:18:07.973412169Z running +redis a8784a6f176fdff2ede5e350216d9fc94963c57ff611944cac275fc61df49b5b 2026-10-19T20:18:07.799371434Z running diff --git a/evidence/restart-before.txt b/evidence/restart-before.txt new file mode 100644 index 00000000..54505574 --- /dev/null +++ b/evidence/restart-before.txt @@ -0,0 +1,3 @@ +api dafaccaefd42497d456f3e26d23ac6be4f70f0e37949c138328d0c97295311b3 2026-10-19T20:11:47.430509928Z running +postgres 9c96af6664fb6aae298d6153c6ecca2d88260d0e45c6e04f9642b45c669db5fb 2026-10-19T18:28:42.086328397Z running +redis a8784a6f176fdff2ede5e350216d9fc94963c57ff611944cac275fc61df49b5b 2026-10-19T19:26:54.47293161Z running diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..92154196 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1 @@ +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 00000000..ba697e37 --- /dev/null +++ b/evidence/student-tests.txt @@ -0,0 +1,22 @@ +test_concurrency_100_messages_10_clients (test_api.ApiTests.test_concurrency_100_messages_10_clients) ... ok +test_duplicate_username (test_api.ApiTests.test_duplicate_username) ... ok +test_empty_message (test_api.ApiTests.test_empty_message) ... ok +test_foreign_chat (test_api.ApiTests.test_foreign_chat) ... ok +test_malformed_json (test_api.ApiTests.test_malformed_json) ... ok +test_multiple_pages_and_cursor_scope (test_api.ApiTests.test_multiple_pages_and_cursor_scope) ... ok +test_validation_and_auth (test_api.ApiTests.test_validation_and_auth) ... ok +test_chat_rollback_after_unknown_member (test_grade4.Grade4Tests.test_chat_rollback_after_unknown_member) ... ok +test_equal_timestamp_pages (test_grade4.Grade4Tests.test_equal_timestamp_pages) ... ok +test_login_logout_and_legacy_header (test_grade4.Grade4Tests.test_login_logout_and_legacy_header) ... ok +test_nul_in_persisted_fields_returns_400 (test_grade4.Grade4Tests.test_nul_in_persisted_fields_returns_400) ... ok +test_registration_race (test_grade4.Grade4Tests.test_registration_race) ... ok +test_unicode_password_with_colon_and_hash (test_grade4.Grade4Tests.test_unicode_password_with_colon_and_hash) ... ok +test_cursor_requires_complete_utc_datetime (test_pagination.PaginationTests.test_cursor_requires_complete_utc_datetime) ... ok +test_cursor_round_trip_and_scope (test_pagination.PaginationTests.test_cursor_round_trip_and_scope) ... ok +test_invalid_limits_and_cursors (test_pagination.PaginationTests.test_invalid_limits_and_cursors) ... ok + +---------------------------------------------------------------------- +Ran 16 tests in 5.023s + +OK +PASS: 10 clients; 100 POST; 100 unique messages; IDs/text match diff --git a/migrations/01_initial.sql b/migrations/01_initial.sql new file mode 100644 index 00000000..c26001b5 --- /dev/null +++ b/migrations/01_initial.sql @@ -0,0 +1,30 @@ +CREATE TABLE users ( + id UUID PRIMARY KEY, + username VARCHAR(32) NOT NULL UNIQUE, + display_name VARCHAR(100) NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title VARCHAR(100) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id), + user_id UUID NOT NULL REFERENCES users(id), + PRIMARY KEY (chat_id, user_id) +); + +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id), + sender_id UUID NOT NULL REFERENCES users(id), + text VARCHAR(4000) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id); +CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id); diff --git a/migrations/02_chat_order.sql b/migrations/02_chat_order.sql new file mode 100644 index 00000000..0922abd8 --- /dev/null +++ b/migrations/02_chat_order.sql @@ -0,0 +1 @@ +CREATE INDEX chats_order_idx ON chats (created_at, id); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..b1807912 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,18 @@ +annotated-doc==0.0.5 +annotated-types==0.8.0 +anyio==4.15.1 +click==8.5.0 +fastapi==0.143.0 +h11==0.16.0 +idna==3.20 +opentelemetry-api==1.45.1 +pydantic==2.14.1 +pydantic_core==2.50.1 +starlette==1.7.0 +typing-inspection==0.4.4 +typing_extensions==4.16.0 +uvicorn==0.54.0 +psycopg[binary]==3.3.6 +psycopg-pool==3.3.3 +argon2-cffi==25.1.0 +redis==8.1.0 diff --git a/scripts/check_grade4.py b/scripts/check_grade4.py new file mode 100644 index 00000000..66dd9b31 --- /dev/null +++ b/scripts/check_grade4.py @@ -0,0 +1,85 @@ +"""Explicit local Docker checks: expiry, then Redis/PostgreSQL outages.""" +import argparse +import subprocess +import sys +import time +from pathlib import Path +from uuid import uuid4 + + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +from client import Client, Failure, check + + +def docker(*args): + subprocess.run(["docker", *args], cwd=ROOT, check=True, timeout=90, + stdout=subprocess.DEVNULL) + + +def wait_ready(c): + deadline = time.monotonic() + 45 + while True: + try: + c.call("GET", "/health/ready", schema="Health") + return + except Failure: + if time.monotonic() >= deadline: + raise + time.sleep(0.2) + + +def check_expiry(base_url): + c = Client(base_url, timeout=8) + wait_ready(c) + actor = c.user("expiry") + c.call("GET", "/api/v1/users/me", actor=actor, schema="User") + time.sleep(2.2) + c.call("GET", "/api/v1/users/me", 401, actor=actor) + print("PASS: SESSION_TTL_SECONDS=2; active token becomes 401 after expiry") + + +def check_outage(c, service, stop, start): + wait_ready(c) + actor = c.user("outage") + try: + stop() + for path in ("/health/ready", "/api/v1/users/me"): + response = c.call("GET", path, 503, + actor=actor if path.startswith("/api/") else None) + check(response["elapsed"] < 8, service + " failure took too long") + check(response["json"]["error"]["code"] == "unavailable", "wrong outage error") + c.call("GET", "/health/live", schema="Health") + c.call("GET", "/api/v1/users/me", 401) + finally: + start() + wait_ready(c) + c.call("GET", "/api/v1/users/me", actor=actor, schema="User") + print("PASS: " + service + " outage -> bounded 503; live=200; anonymous=401; old token recovers") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--base-url", default="http://localhost:8080") + parser.add_argument("--expiry-port", type=int, default=8081) + args = parser.parse_args() + check(1 <= args.expiry_port <= 65535, "invalid expiry port") + name = "lab2-expiry-" + uuid4().hex[:12] + started = False + try: + docker("compose", "run", "-d", "--rm", "--no-deps", "--name", name, + "-e", "SESSION_TTL_SECONDS=2", "-p", "127.0.0.1:" + str(args.expiry_port) + ":8080", "api") + started = True + check_expiry("http://127.0.0.1:" + str(args.expiry_port)) + finally: + if started: + docker("stop", name) + c = Client(args.base_url, timeout=8) + for service in ("redis", "postgres"): + check_outage(c, service, + lambda s=service: docker("compose", "stop", s), + lambda s=service: docker("compose", "up", "-d", "--wait", s)) + + +if __name__ == "__main__": + main() diff --git a/scripts/explain_history.py b/scripts/explain_history.py new file mode 100644 index 00000000..cb4d87a7 --- /dev/null +++ b/scripts/explain_history.py @@ -0,0 +1,60 @@ +"""EXPLAIN on 10,000 synthetic messages; transaction rolls fixtures back.""" +import sys +from pathlib import Path +from uuid import uuid4 + +import psycopg +from argon2 import PasswordHasher + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from src.db import connection_kwargs +from src.main import HISTORY_AFTER_SQL, HISTORY_FIRST_SQL + + +def explain(conn, query, params): + plan = conn.execute("EXPLAIN (ANALYZE, BUFFERS) " + query, params).fetchall() + text = "\n".join(row["QUERY PLAN"] for row in plan) + print(text) + if "messages_history_idx" not in text or "Seq Scan on messages" in text: + raise AssertionError("Expected history index without full messages scan") + + +def main(): + user_id, chat_id = uuid4(), uuid4() + with psycopg.connect(**connection_kwargs()) as conn: + print(conn.execute("SELECT version() AS version").fetchone()["version"]) + with conn.transaction(force_rollback=True): + conn.execute( + "INSERT INTO users (id,username,display_name,password_hash) VALUES (%s,%s,%s,%s)", + (user_id, "plan_" + uuid4().hex[:20], "EXPLAIN fixture", + PasswordHasher().hash("Synthetic-password-123")), + ) + conn.execute("INSERT INTO chats (id,title) VALUES (%s,%s)", (chat_id, "EXPLAIN fixture")) + conn.execute("INSERT INTO chat_members (chat_id,user_id) VALUES (%s,%s)", (chat_id, user_id)) + conn.execute(""" + INSERT INTO messages (id,chat_id,sender_id,text,created_at) + SELECT gen_random_uuid(), %s, %s, 'EXPLAIN fixture ' || n, + TIMESTAMPTZ '2026-01-01T00:00:00Z' + n * INTERVAL '1 microsecond' + FROM generate_series(1,10000) AS n + """, (chat_id, user_id)) + conn.execute("ANALYZE messages") + count = conn.execute("SELECT count(*) AS n FROM messages WHERE chat_id=%s", + (chat_id,)).fetchone()["n"] + assert count >= 10000 + print("Fixture messages:", count) + print("FIRST PAGE: LIMIT 51 (50 items + lookahead)") + explain(conn, HISTORY_FIRST_SQL, (chat_id, 51)) + # OFFSET only selects a reproducible fixture boundary, outside the page query. + boundary = conn.execute( + "SELECT created_at,id FROM messages WHERE chat_id=%s " + "ORDER BY created_at,id OFFSET 8999 LIMIT 1", (chat_id,), + ).fetchone() + print("LATER PAGE: after message 9000, LIMIT 51") + explain(conn, HISTORY_AFTER_SQL, + (chat_id, boundary["created_at"], boundary["id"], 51)) + conn.execute("ANALYZE messages") + print("PASS: 10000 messages; first/later pages use messages_history_idx; fixtures rolled back") + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..a46f4dcd --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,4 @@ +@echo off +cd /d "%~dp0.." +python scripts\restart.py +exit /b %errorlevel% diff --git a/scripts/restart.py b/scripts/restart.py new file mode 100644 index 00000000..4597057b --- /dev/null +++ b/scripts/restart.py @@ -0,0 +1,34 @@ +"""Restart the complete lab stack; keep volumes and record actual start times.""" +import subprocess +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[1] +SERVICES = ["api", "postgres", "redis"] + + +def snapshot(filename): + ids = subprocess.check_output( + ["docker", "compose", "ps", "--all", "-q", *SERVICES], cwd=ROOT, text=True + ).split() + if len(ids) != 3: + raise RuntimeError("Expected one api, postgres and redis container") + template = ('{{index .Config.Labels "com.docker.compose.service"}} ' + '{{.Id}} {{.State.StartedAt}} {{.State.Status}}') + lines = subprocess.check_output( + ["docker", "inspect", "--format", template, *ids], cwd=ROOT, text=True + ) + (ROOT / "evidence").mkdir(exist_ok=True) + (ROOT / "evidence" / filename).write_text(lines, encoding="utf-8") + + +def main(): + snapshot("restart-before.txt") + subprocess.run(["docker", "compose", "stop", *SERVICES], cwd=ROOT, check=True, timeout=45) + subprocess.run(["docker", "compose", "up", "-d", "--wait", "api"], + cwd=ROOT, check=True, timeout=40) + snapshot("restart-after.txt") + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..edd8888c --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +exec python3 scripts/restart.py diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/db.py b/src/db.py new file mode 100644 index 00000000..fbb7bde3 --- /dev/null +++ b/src/db.py @@ -0,0 +1,29 @@ +import os + +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool + + +def connection_kwargs(): + return { + "host": os.getenv("POSTGRES_HOST", "postgres"), + "port": int(os.getenv("POSTGRES_PORT", "5432")), + "dbname": os.environ["POSTGRES_DB"], + "user": os.environ["POSTGRES_USER"], + "password": os.environ["POSTGRES_PASSWORD"], + "connect_timeout": 5, + "options": "-c statement_timeout=5000 -c lock_timeout=3000", + "autocommit": True, + "row_factory": dict_row, + } + + +pool = ConnectionPool( + kwargs=connection_kwargs(), + min_size=1, + max_size=5, + max_waiting=20, + timeout=3, + check=ConnectionPool.check_connection, + open=False, +) diff --git a/src/errors.py b/src/errors.py new file mode 100644 index 00000000..73e36a37 --- /dev/null +++ b/src/errors.py @@ -0,0 +1,14 @@ +class ApiError(Exception): + def __init__(self, status, code, message): + super().__init__(message) + self.status = status + self.code = code + self.message = message + + +def invalid(message="Неверный запрос"): + raise ApiError(400, "invalid_request", message) + + +def unauthorized(): + raise ApiError(401, "unauthorized", "Неверные данные авторизации") diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..64c30451 --- /dev/null +++ b/src/main.py @@ -0,0 +1,398 @@ +import base64 +import binascii +import logging +import re +import time +from contextlib import asynccontextmanager +from datetime import datetime, timezone +from uuid import UUID, uuid4 + +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError +from fastapi import FastAPI, Header, Query, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse, Response +from psycopg import InterfaceError, OperationalError +from psycopg.errors import ForeignKeyViolation, UniqueViolation +from pydantic import BaseModel, ConfigDict, Field, field_validator +from redis.exceptions import RedisError +from starlette.concurrency import run_in_threadpool +from starlette.exceptions import HTTPException as StarletteHTTPException + +from src.db import pool +from src.errors import ApiError, invalid, unauthorized +from src.pagination import encode_cursor, parse_page +from src.sessions import issue_session, redis_client + + +log = logging.getLogger("messenger") +password_hasher = PasswordHasher() +ready = False + + +def parse_uuid(value): + try: + return UUID(value) + except (ValueError, TypeError, AttributeError): + invalid("Некорректный UUID") + + +def row_response(row): + result = {} + for key, value in row.items(): + if isinstance(value, UUID): + value = str(value) + elif isinstance(value, datetime): + value = value.astimezone(timezone.utc).isoformat( + timespec="microseconds" + ).replace("+00:00", "Z") + elif key == "member_ids": + value = [str(member) for member in value] + result[key] = value + return result + + +class InputModel(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + + @field_validator("*", check_fields=False) + @classmethod + def reject_blank(cls, value): + if isinstance(value, str) and not value.strip(): + raise ValueError("Строка не должна быть пустой") + return value + + @field_validator("display_name", "title", "text", check_fields=False) + @classmethod + def reject_nul(cls, value): + if "\u0000" in value: + raise ValueError("Нулевой символ недопустим в текстовом поле") + return value + + +class CreateUser(InputModel): + username: str = Field(min_length=3, max_length=32) + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + @field_validator("username") + @classmethod + def validate_username(cls, value): + if re.fullmatch(r"[a-z0-9_]{3,32}", value) is None: + raise ValueError("Некорректный username") + return value + + +class CreateChat(InputModel): + title: str = Field(min_length=1, max_length=100) + member_ids: list[str] = Field(min_length=1, max_length=100) + + +class CreateMessage(InputModel): + text: str = Field(min_length=1, max_length=4000) + + +def bearer_token(value): + scheme, _, token = (value or "").partition(" ") + if scheme.lower() != "bearer" or not token: + unauthorized() + return token + + +def current_user(value): + token = bearer_token(value) + user_id = redis_client.get("session:" + token) + if user_id is None: + unauthorized() + with pool.connection() as conn: + user = conn.execute( + "SELECT id, username, display_name, created_at FROM users WHERE id = %s", + (UUID(user_id),), + ).fetchone() + if user is None: + unauthorized() + return row_response(user) + + +@asynccontextmanager +async def lifespan(app): + global ready + try: + await run_in_threadpool(pool.open, wait=True, timeout=10) + await run_in_threadpool(redis_client.ping) + ready = True + log.info("startup ready=true") + yield + finally: + ready = False + redis_client.close() + pool.close() + log.info("shutdown complete") + + +app = FastAPI(title="Lab 2 Messenger", lifespan=lifespan) + + +def error_response(request, status, code, message): + request_id = request.state.request_id + headers = {"X-Request-Id": request_id} + if status == 401: + if request.method == "POST" and request.url.path == "/api/v1/auth/sessions": + headers["WWW-Authenticate"] = 'Basic realm="messenger", charset="UTF-8"' + else: + headers["WWW-Authenticate"] = 'Bearer realm="messenger"' + return JSONResponse( + status_code=status, + content={"error": {"code": code, "message": message, "request_id": request_id}}, + headers=headers, + ) + + +@app.exception_handler(ApiError) +async def api_error(request, exc): + return error_response(request, exc.status, exc.code, exc.message) + + +@app.exception_handler(RequestValidationError) +async def validation_error(request, exc): + return error_response(request, 400, "invalid_request", "Некорректные поля или JSON") + + +@app.exception_handler(StarletteHTTPException) +async def http_error(request, exc): + code = "not_found" if exc.status_code == 404 else "invalid_request" + return error_response(request, exc.status_code, code, "Некорректный запрос") + + +@app.middleware("http") +async def process_request(request: Request, call_next): + request.state.request_id = str(uuid4()) + started = time.perf_counter() + try: + is_login = request.method == "POST" and request.url.path == "/api/v1/auth/sessions" + public = request.method == "POST" and request.url.path in ( + "/api/v1/users", "/api/v1/auth/sessions" + ) + if request.url.path.startswith("/api/v1/") and not public: + request.state.user = await run_in_threadpool( + current_user, request.headers.get("Authorization") + ) + if is_login: + if await request.body(): + invalid("Для входа тело запроса должно быть пустым") + elif request.method == "POST" and request.url.path.startswith("/api/v1/"): + media_type = request.headers.get("content-type", "").split(";")[0] + if media_type.strip().lower() != "application/json": + raise ApiError(415, "unsupported_media_type", "Нужен application/json") + response = await call_next(request) + except ApiError as exc: + response = error_response(request, exc.status, exc.code, exc.message) + except (OperationalError, InterfaceError, RedisError): + response = error_response(request, 503, "unavailable", "Хранилище недоступно") + except Exception as exc: + # Не пишем body, Authorization, SQL или текст исключения в журнал. + log.error("request_failed type=%s request_id=%s", + type(exc).__name__, request.state.request_id) + response = error_response(request, 500, "internal_error", "Внутренняя ошибка") + response.headers["X-Request-Id"] = request.state.request_id + route = request.scope.get("route") + log.info("request method=%s route=%s status=%s duration_ms=%.2f request_id=%s", + request.method, getattr(route, "path", "unmatched"), response.status_code, + (time.perf_counter() - started) * 1000, request.state.request_id) + return response + + +@app.get("/health/live") +def live(): + return {"status": "ok"} + + +@app.get("/health/ready") +def readiness(): + if not ready: + raise ApiError(503, "unavailable", "Приложение не готово") + with pool.connection() as conn: + conn.execute("SELECT 1") + redis_client.ping() + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +def create_user(body: CreateUser): + password_hash = password_hasher.hash(body.password) + try: + with pool.connection() as conn: + user = conn.execute( + "INSERT INTO users (id, username, display_name, password_hash) " + "VALUES (%s, %s, %s, %s) RETURNING id, username, display_name, created_at", + (uuid4(), body.username, body.display_name, password_hash), + ).fetchone() + except UniqueViolation as exc: + if exc.diag.constraint_name == "users_username_key": + raise ApiError(409, "conflict", "Username занят") from None + raise + return row_response(user) + + +@app.post("/api/v1/auth/sessions", status_code=201) +def login(authorization: str | None = Header(default=None)): + scheme, _, encoded = (authorization or "").partition(" ") + if scheme.lower() != "basic" or not encoded: + unauthorized() + try: + decoded = base64.b64decode(encoded, validate=True).decode("utf-8") + username, password = decoded.split(":", 1) + except (ValueError, binascii.Error): + unauthorized() + if re.fullmatch(r"[a-z0-9_]{3,32}", username) is None or not 12 <= len(password) <= 128: + unauthorized() + with pool.connection() as conn: + user = conn.execute( + "SELECT id, username, display_name, password_hash, created_at " + "FROM users WHERE username = %s", (username,), + ).fetchone() + if user is None: + unauthorized() + try: + password_hasher.verify(user["password_hash"], password) + except VerifyMismatchError: + unauthorized() + token, expires_at = issue_session(user["id"]) + del user["password_hash"] + return {"token": token, "token_type": "Bearer", "expires_at": expires_at, + "user": row_response(user)} + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def logout(request: Request): + token = bearer_token(request.headers.get("Authorization")) + redis_client.delete("session:" + token) + return Response(status_code=204) + + +@app.get("/api/v1/users/me") +def get_me(request: Request): + return request.state.user + + +def require_member(conn, chat_id, user_id): + found = conn.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, UUID(user_id)), + ).fetchone() + if found is None: + raise ApiError(404, "not_found", "Чат не найден") + + +CHAT_SELECT = """ + SELECT c.id, c.title, c.created_at, + ARRAY(SELECT user_id FROM chat_members + WHERE chat_id = c.id ORDER BY user_id) AS member_ids + FROM chats c + JOIN chat_members mine ON mine.chat_id = c.id + WHERE mine.user_id = %s +""" + +HISTORY_FIRST_SQL = """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages WHERE chat_id = %s + ORDER BY created_at, id LIMIT %s +""" + +HISTORY_AFTER_SQL = """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages WHERE chat_id = %s AND (created_at, id) > (%s, %s) + ORDER BY created_at, id LIMIT %s +""" + + +def page_response(rows, size, scope): + items = [row_response(row) for row in rows[:size]] + cursor = encode_cursor(scope, items[-1]) if len(rows) > size else None + return {"items": items, "next_cursor": cursor} + + +@app.post("/api/v1/chats", status_code=201) +def create_chat(body: CreateChat, request: Request): + members = sorted(parse_uuid(value) for value in body.member_ids) + if len(members) != len(set(members)): + invalid("Участники повторяются") + if UUID(request.state.user["id"]) not in members: + invalid("Вызывающий должен входить в member_ids") + try: + with pool.connection() as conn: + with conn.transaction(): + chat = conn.execute( + "INSERT INTO chats (id, title) VALUES (%s, %s) " + "RETURNING id, title, created_at", (uuid4(), body.title), + ).fetchone() + with conn.cursor() as cur: + cur.executemany( + "INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", + [(chat["id"], member) for member in members], + ) + except ForeignKeyViolation: + invalid("Неизвестный участник") + chat["member_ids"] = members + return row_response(chat) + + +@app.get("/api/v1/chats") +def list_chats(request: Request, limit: str = Query(default="50"), + cursor: str | None = Query(default=None)): + user_id = request.state.user["id"] + scope = "chats:" + user_id + size, after = parse_page(limit, cursor, scope) + query = CHAT_SELECT + params = [UUID(user_id)] + if after is not None: + query += " AND (c.created_at, c.id) > (%s, %s)" + params.extend(after) + query += " ORDER BY c.created_at, c.id LIMIT %s" + params.append(size + 1) + with pool.connection() as conn: + rows = conn.execute(query, params).fetchall() + return page_response(rows, size, scope) + + +@app.get("/api/v1/chats/{chat_id}") +def get_chat(chat_id: str, request: Request): + with pool.connection() as conn: + chat = conn.execute( + CHAT_SELECT + " AND c.id = %s", + (UUID(request.state.user["id"]), parse_uuid(chat_id)), + ).fetchone() + if chat is None: + raise ApiError(404, "not_found", "Чат не найден") + return row_response(chat) + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def create_message(chat_id: str, body: CreateMessage, request: Request): + chat_uuid = parse_uuid(chat_id) + user_id = request.state.user["id"] + with pool.connection() as conn: + require_member(conn, chat_uuid, user_id) + message = conn.execute( + "INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s) " + "RETURNING id, chat_id, sender_id, text, created_at", + (uuid4(), chat_uuid, UUID(user_id), body.text), + ).fetchone() + return row_response(message) + + +@app.get("/api/v1/chats/{chat_id}/messages") +def list_messages(chat_id: str, request: Request, limit: str = Query(default="50"), + cursor: str | None = Query(default=None)): + chat_uuid = parse_uuid(chat_id) + scope = "messages:" + str(chat_uuid) + size, after = parse_page(limit, cursor, scope) + with pool.connection() as conn: + require_member(conn, chat_uuid, request.state.user["id"]) + if after is None: + rows = conn.execute(HISTORY_FIRST_SQL, (chat_uuid, size + 1)).fetchall() + else: + rows = conn.execute( + HISTORY_AFTER_SQL, (chat_uuid, after[0], after[1], size + 1) + ).fetchall() + return page_response(rows, size, scope) diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..82e54478 --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,37 @@ +from pathlib import Path + +import psycopg + +from src.db import connection_kwargs + + +def main(): + files = sorted((Path(__file__).resolve().parents[1] / "migrations").glob("*.sql")) + if not files: + raise RuntimeError("Миграции не найдены") + with psycopg.connect(**connection_kwargs()) as conn: + conn.execute(""" + CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT now() + ) + """) + for file in files: + applied = False + with conn.transaction(): + # Один мигратор за раз, даже при одновременном запуске команд. + conn.execute("SELECT pg_advisory_xact_lock(202602)") + exists = conn.execute( + "SELECT 1 FROM schema_migrations WHERE version = %s", (file.name,) + ).fetchone() + if exists is None: + conn.execute(file.read_text(encoding="utf-8")) + conn.execute( + "INSERT INTO schema_migrations (version) VALUES (%s)", (file.name,) + ) + applied = True + print(("APPLIED " if applied else "SKIP ") + file.name) + + +if __name__ == "__main__": + main() diff --git a/src/pagination.py b/src/pagination.py new file mode 100644 index 00000000..03615854 --- /dev/null +++ b/src/pagination.py @@ -0,0 +1,47 @@ +import base64 +import binascii +import json +import re +from datetime import datetime +from uuid import UUID + +from src.errors import invalid + + +def encode_cursor(scope, item): + data = {"scope": scope, "created_at": item["created_at"], "id": item["id"]} + raw = json.dumps(data, separators=(",", ":")).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") + + +def parse_page(limit, cursor, scope): + if len(limit) > 10 or re.fullmatch(r"[0-9]+", limit) is None: + invalid("limit должен быть целым числом от 1 до 100") + size = int(limit) + if not 1 <= size <= 100: + invalid("limit должен быть от 1 до 100") + if cursor is None: + return size, None + if not cursor or len(cursor) > 2048: + invalid("Некорректный cursor") + try: + raw = base64.b64decode( + cursor + "=" * (-len(cursor) % 4), altchars=b"-_", validate=True + ) + data = json.loads(raw) + if not isinstance(data, dict) or set(data) != {"scope", "created_at", "id"}: + raise ValueError + if data["scope"] != scope or not isinstance(data["created_at"], str): + raise ValueError + if re.fullmatch( + r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]{1,6})?Z", + data["created_at"], + ) is None: + raise ValueError + created_at = datetime.fromisoformat(data["created_at"][:-1] + "+00:00") + if created_at.tzinfo is None: + raise ValueError + item_id = UUID(data["id"]) + except (ValueError, TypeError, AttributeError, binascii.Error): + invalid("Некорректный cursor или cursor от другого ресурса") + return size, (created_at, item_id) diff --git a/src/run.py b/src/run.py new file mode 100644 index 00000000..d01a0b04 --- /dev/null +++ b/src/run.py @@ -0,0 +1,23 @@ +import logging +import os + +import uvicorn + + +if __name__ == "__main__": + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(name)s %(message)s", + ) + logging.getLogger("messenger").info( + "config app_env=%s", os.getenv("APP_ENV", "lab") + ) + uvicorn.run( + "src.main:app", + host=os.getenv("APP_HOST", "0.0.0.0"), + port=int(os.getenv("APP_PORT", "8080")), + workers=1, + timeout_graceful_shutdown=5, + timeout_keep_alive=1, + access_log=False, + ) \ No newline at end of file diff --git a/src/sessions.py b/src/sessions.py new file mode 100644 index 00000000..82854049 --- /dev/null +++ b/src/sessions.py @@ -0,0 +1,33 @@ +import os +import secrets +import time +from datetime import datetime, timezone + +from redis import Redis +from redis.backoff import NoBackoff +from redis.retry import Retry + + +redis_client = Redis( + host=os.getenv("REDIS_HOST", "redis"), + port=int(os.getenv("REDIS_PORT", "6379")), + decode_responses=True, + socket_connect_timeout=2, + socket_timeout=2, + max_connections=10, + retry=Retry(NoBackoff(), 0), +) + +SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) +if SESSION_TTL_SECONDS <= 0: + raise RuntimeError("SESSION_TTL_SECONDS должен быть положительным") + + +def issue_session(user_id): + token = secrets.token_urlsafe(32) + expires_ms = int(time.time() * 1000) + SESSION_TTL_SECONDS * 1000 + redis_client.set("session:" + token, str(user_id), pxat=expires_ms) + expires_at = datetime.fromtimestamp( + expires_ms / 1000, timezone.utc + ).isoformat(timespec="milliseconds").replace("+00:00", "Z") + return token, expires_at diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 00000000..fca6be9e --- /dev/null +++ b/student-tests/test_api.py @@ -0,0 +1,122 @@ +import sys +import unittest +import uuid +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path +from urllib.parse import quote + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +from client import Client, timestamp + + +class ApiTests(unittest.TestCase): + def setUp(self): + self.c = Client() + self.alice, self.bob, self.eve, self.chat = self.c.bootstrap() + self.path = "/api/v1/chats/" + self.chat["id"] + + def read_all(self, client, actor, path, limit=17): + items = [] + cursor = None + seen = set() + for _ in range(1000): + url = path + "?limit=" + str(limit) + if cursor is not None: + url += "&cursor=" + quote(cursor, safe="") + page = client.call("GET", url, actor=actor, schema="MessagePage")["json"] + items.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None: + return items + self.assertNotIn(cursor, seen, "cursor зациклился") + seen.add(cursor) + self.fail("Слишком много страниц") + + def test_malformed_json(self): + result = self.c.call("POST", "/api/v1/users", 400, + raw=b'{"username":', + headers={"Content-Type": "application/json"}) + self.assertEqual(result["json"]["error"]["code"], "invalid_request") + + def test_foreign_chat(self): + self.c.call("GET", self.path, 404, actor=self.eve) + self.c.call("GET", self.path + "/messages", 404, actor=self.eve) + self.c.call("POST", self.path + "/messages", 404, + actor=self.eve, body={"text": "Чужой чат"}) + page = self.c.call("GET", "/api/v1/chats", actor=self.eve, + schema="ChatPage")["json"] + self.assertNotIn(self.chat["id"], [item["id"] for item in page["items"]]) + + def test_empty_message(self): + for value in ("", " ", "\n\t"): + with self.subTest(text=repr(value)): + self.c.call("POST", self.path + "/messages", 400, + actor=self.alice, body={"text": value}) + + def test_duplicate_username(self): + self.c.call("POST", "/api/v1/users", 409, + body=self.alice["registration"]) + + def test_multiple_pages_and_cursor_scope(self): + expected = [self.c.message(self.alice, self.chat, "Страница " + str(i))["json"] + for i in range(7)] + actual = self.read_all(self.c, self.bob, self.path + "/messages", limit=2) + self.assertEqual(actual, sorted(expected, key=lambda x: + (timestamp(x["created_at"]), uuid.UUID(x["id"]).int))) + self.assertEqual(len({item["id"] for item in actual}), 7) + page = self.c.call("GET", self.path + "/messages?limit=1", + actor=self.alice, schema="MessagePage")["json"] + other = self.c.call("POST", "/api/v1/chats", 201, actor=self.alice, + body={"title": "Другой", "member_ids": [self.alice["id"]]}, + schema="Chat")["json"] + self.c.call("GET", "/api/v1/chats/" + other["id"] + "/messages?cursor=" + + quote(page["next_cursor"], safe=""), 400, actor=self.alice) + + def test_validation_and_auth(self): + for body in ({"text": 123}, {"text": "ok", "sender_id": self.bob["id"]}, + {"text": "x" * 4001}): + self.c.call("POST", self.path + "/messages", 400, + actor=self.alice, body=body) + for limit in ("0", "101", "abc", "1.5"): + self.c.call("GET", self.path + "/messages?limit=" + limit, + 400, actor=self.alice) + self.c.call("GET", self.path + "/messages?cursor=garbage", 400, + actor=self.alice) + self.c.call("GET", "/api/v1/users/me", 401) + self.c.call("GET", "/api/v1/users/me", 401, + headers={"X-User-Id": str(uuid.uuid4())}) + self.c.call("POST", self.path + "/messages", 401, raw=b'{', + headers={"Content-Type": "application/json"}) + self.c.call("POST", self.path + "/messages", 415, actor=self.alice, + raw=b'plain', headers={"Content-Type": "text/plain"}) + for members in ([self.alice["id"], self.alice["id"]], + [self.bob["id"]], [self.alice["id"], str(uuid.uuid4())]): + self.c.call("POST", "/api/v1/chats", 400, actor=self.alice, + body={"title": "Неверный чат", "member_ids": members}) + + def test_concurrency_100_messages_10_clients(self): + # У каждого из 10 потоков свой HTTP-клиент и 10 последовательных POST. + def send_batch(worker): + client = Client() + sent = [] + for i in range(10): + text = "worker=" + str(worker) + ";message=" + str(i) + sent.append(client.message(self.alice, self.chat, text)["json"]) + return sent + + with ThreadPoolExecutor(max_workers=10) as pool: + batches = list(pool.map(send_batch, range(10))) + sent = [item for batch in batches for item in batch] + actual = self.read_all(self.c, self.bob, self.path + "/messages") + self.assertEqual(len(sent), 100) + self.assertEqual(len(actual), 100) + self.assertEqual(len({item["id"] for item in actual}), 100) + self.assertEqual({item["id"] for item in actual}, {item["id"] for item in sent}) + self.assertEqual({item["text"] for item in actual}, {item["text"] for item in sent}) + self.assertTrue(all(item["sender_id"] == self.alice["id"] for item in actual)) + print("PASS: 10 clients; 100 POST; 100 unique messages; IDs/text match") + + +if __name__ == "__main__": + unittest.main(verbosity=2) \ No newline at end of file diff --git a/student-tests/test_grade4.py b/student-tests/test_grade4.py new file mode 100644 index 00000000..f5dffd5f --- /dev/null +++ b/student-tests/test_grade4.py @@ -0,0 +1,125 @@ +"""HTTP + PostgreSQL checks; run inside api so its DB settings are available.""" +import base64 +import sys +import threading +import unittest +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path +from uuid import uuid4 + +import psycopg + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +sys.path.insert(0, str(ROOT)) +from client import Client +from src.db import connection_kwargs + + +class Grade4Tests(unittest.TestCase): + def setUp(self): + self.c = Client() + + def test_registration_race(self): + body = {"username": "race_" + uuid4().hex[:16], + "display_name": "Гонка регистрации", "password": "Example-password-123"} + barrier = threading.Barrier(4) + + def register(_): + c = Client() + barrier.wait(timeout=10) + return c.call("POST", "/api/v1/users", [201, 409], body=body)["status"] + + with ThreadPoolExecutor(max_workers=4) as workers: + statuses = list(workers.map(register, range(4))) + self.assertEqual(sorted(statuses), [201, 409, 409, 409]) + with psycopg.connect(**connection_kwargs()) as conn: + row = conn.execute("SELECT count(*) AS n FROM users WHERE username=%s", + (body["username"],)).fetchone() + self.assertEqual(row["n"], 1) + + def test_chat_rollback_after_unknown_member(self): + alice = self.c.user("rollback") + title = "rollback_" + uuid4().hex + with psycopg.connect(**connection_kwargs()) as conn: + before = conn.execute("SELECT count(*) AS n FROM chat_members WHERE user_id=%s", + (alice["id"],)).fetchone()["n"] + self.c.call("POST", "/api/v1/chats", 400, actor=alice, + body={"title": title, "member_ids": [alice["id"], str(uuid4())]}) + with psycopg.connect(**connection_kwargs()) as conn: + self.assertEqual(conn.execute("SELECT count(*) AS n FROM chats WHERE title=%s", + (title,)).fetchone()["n"], 0) + after = conn.execute("SELECT count(*) AS n FROM chat_members WHERE user_id=%s", + (alice["id"],)).fetchone()["n"] + self.assertEqual(before, after) + + def test_login_logout_and_legacy_header(self): + alice = self.c.user("sessions") + wrong = base64.b64encode( + (alice["registration"]["username"] + ":wrong-password-123").encode() + ).decode() + self.c.call("POST", "/api/v1/auth/sessions", 401, + headers={"Authorization": "Basic " + wrong}) + self.c.call("GET", "/api/v1/users/me", 401, + headers={"X-User-Id": alice["id"]}) + me = self.c.call("GET", "/api/v1/users/me", actor=alice, + headers={"X-User-Id": str(uuid4())}, schema="User")["json"] + self.assertEqual(me["id"], alice["id"]) + self.c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=alice) + self.c.call("GET", "/api/v1/users/me", 401, actor=alice) + self.c.call("DELETE", "/api/v1/auth/sessions/current", 401, actor=alice) + + def test_unicode_password_with_colon_and_hash(self): + body = {"username": "utf_" + uuid4().hex[:16], "display_name": "Студент 👋", + "password": "Пароль:мандарин🍊123"} + user = self.c.call("POST", "/api/v1/users", 201, body=body, schema="User")["json"] + basic = base64.b64encode((body["username"] + ":" + body["password"]).encode()).decode() + session = self.c.call("POST", "/api/v1/auth/sessions", 201, + headers={"Authorization": "Basic " + basic}, schema="Session")["json"] + self.assertEqual(session["user"], user) + self.assertEqual(len(base64.urlsafe_b64decode(session["token"] + "=")), 32) + with psycopg.connect(**connection_kwargs()) as conn: + stored = conn.execute("SELECT password_hash FROM users WHERE id=%s", + (user["id"],)).fetchone()["password_hash"] + self.assertTrue(stored.startswith("$argon2id$")) + self.assertNotIn(body["password"], stored) + + def test_equal_timestamp_pages(self): + alice, bob, _, chat = self.c.bootstrap() + ids = [uuid4() for _ in range(5)] + with psycopg.connect(**connection_kwargs()) as conn: + with conn.cursor() as cur: + cur.executemany( + "INSERT INTO messages (id,chat_id,sender_id,text,created_at) " + "VALUES (%s,%s,%s,%s,'2026-01-01T00:00:00Z')", + [(i, chat["id"], alice["id"], "Одинаковое время") for i in ids], + ) + from urllib.parse import quote + found, cursor = [], None + for _ in range(6): + path = "/api/v1/chats/" + chat["id"] + "/messages?limit=2" + if cursor: + path += "&cursor=" + quote(cursor, safe="") + page = self.c.call("GET", path, actor=bob, schema="MessagePage")["json"] + found.extend(x["id"] for x in page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + self.assertIsNone(cursor) + self.assertEqual(found, [str(i) for i in sorted(ids)]) + + def test_nul_in_persisted_fields_returns_400(self): + self.c.call("POST", "/api/v1/users", 400, + body={"username": "nul_" + uuid4().hex[:16], "display_name": "x\u0000y", + "password": "Example-password-123"}) + alice = self.c.user("nul") + self.c.call("POST", "/api/v1/chats", 400, actor=alice, + body={"title": "x\u0000y", "member_ids": [alice["id"]]}) + chat = self.c.call("POST", "/api/v1/chats", 201, actor=alice, + body={"title": "NUL check", "member_ids": [alice["id"]]}, schema="Chat")["json"] + self.c.call("POST", "/api/v1/chats/" + chat["id"] + "/messages", 400, + actor=alice, body={"text": "x\u0000y"}) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/student-tests/test_pagination.py b/student-tests/test_pagination.py new file mode 100644 index 00000000..1c0a37dc --- /dev/null +++ b/student-tests/test_pagination.py @@ -0,0 +1,48 @@ +"""Pure cursor checks: python -m unittest discover -s student-tests -p test_pagination.py.""" +import importlib.util +import unittest +from datetime import datetime, timezone +from uuid import UUID + + +class PaginationTests(unittest.TestCase): + def setUp(self): + self.assertIsNotNone( + importlib.util.find_spec("src.pagination"), + "SQL pagination helper has not been implemented", + ) + from src import pagination + from src.errors import ApiError + self.p = pagination + self.error = ApiError + + def test_cursor_round_trip_and_scope(self): + item = {"id": "00000000-0000-4000-8000-000000000001", + "created_at": "2026-10-19T12:00:00.123456Z"} + cursor = self.p.encode_cursor("messages:chat-a", item) + limit, after = self.p.parse_page("17", cursor, "messages:chat-a") + self.assertEqual(limit, 17) + self.assertEqual(after, (datetime(2026, 10, 19, 12, 0, 0, 123456, + tzinfo=timezone.utc), UUID(item["id"]))) + with self.assertRaises(self.error): + self.p.parse_page("17", cursor, "messages:chat-b") + + def test_invalid_limits_and_cursors(self): + for value in ("0", "101", "1.5", "abc", "-1"): + with self.subTest(limit=value), self.assertRaises(self.error): + self.p.parse_page(value, None, "scope") + for value in ("", "garbage", "!!!!", "bnVsbA", "W10"): + with self.subTest(cursor=value), self.assertRaises(self.error): + self.p.parse_page("50", value, "scope") + self.assertEqual(self.p.parse_page("50", None, "scope"), (50, None)) + + def test_cursor_requires_complete_utc_datetime(self): + for timestamp in ("2026-01-01Z", "2026-01-01T00:00:00", "2026-01-01T00:00:00+03:00"): + item = {"id": "00000000-0000-4000-8000-000000000001", "created_at": timestamp} + cursor = self.p.encode_cursor("scope", item) + with self.subTest(timestamp=timestamp), self.assertRaises(self.error): + self.p.parse_page("50", cursor, "scope") + + +if __name__ == "__main__": + unittest.main(verbosity=2)