diff --git a/.github/workflows/application.yml b/.github/workflows/application.yml new file mode 100644 index 0000000..0812638 --- /dev/null +++ b/.github/workflows/application.yml @@ -0,0 +1,23 @@ +name: Lab2 application +on: [push, pull_request] +permissions: + contents: read +jobs: + application: + runs-on: ubuntu-latest + timeout-minutes: 15 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - run: python scripts/bootstrap.py + - run: docker compose --env-file .env up -d --build --wait --wait-timeout 120 + - run: python scripts/verify.py + - if: always() + uses: actions/upload-artifact@v4 + with: + name: lab2-evidence + path: evidence/ + - if: always() + run: docker compose down diff --git a/DEFENSE.md b/DEFENSE.md new file mode 100644 index 0000000..79c355f --- /dev/null +++ b/DEFENSE.md @@ -0,0 +1,28 @@ +# Что объяснять на защите + +1. **Изменение относительно lab1.** Память Python исчезает при рестарте. + Теперь долговечные данные и сессии находятся в PostgreSQL с named volume. + Пользователь определяется по случайному Bearer-токену; X-User-Id игнорируется. +2. **Пароль и токен.** Argon2id делает перебор паролей дорогим; соль и параметры + находятся внутри hash. Basic содержит base64(username:password), это не + шифрование. Токен — 32 случайных байта, в БД хранится только SHA-256 от него. +3. **Сессия.** Каждый запрос проверяет expires_at в БД. Logout удаляет строку. + После рестарта строка и её прежний срок сохраняются, TTL не продлевается. +4. **Транзакция чата.** INSERT chats и все INSERT memberships идут на одном + соединении до COMMIT. Несуществующий участник нарушает FK, вся транзакция + откатывается. Тест проверяет, что даже строка chats не осталась. +5. **Гонка регистрации.** Два запроса могут одновременно не увидеть username. + Истинную уникальность обеспечивает UNIQUE в БД; один INSERT проходит, + остальные получают конфликт, который API превращает в 409. +6. **Авторизация.** Валидная сессия устанавливает личность. Membership отдельно + определяет право читать/писать конкретный чат. Чужой чат → 404. +7. **Индекс.** B-tree(chat_id,created_at,id) сначала ограничивает чат, затем + позволяет идти от cursor в нужном порядке и взять limit+1 строк. + OFFSET в API не используется. +8. **COMMIT.** Ответ отправляется после подтверждения транзакции. В штатной + PostgreSQL включены fsync и synchronous_commit, но один Docker-host не + защищает от потери диска/volume. Репликация и backup здесь не реализованы. +9. **Как показать.** `make test`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh`, + `make test-student`, `make test-expiry`. Последняя + команда временно ставит TTL=2, затем + восстанавливает обычную конфигурацию. Полный прогон — `make verify`. diff --git a/DESIGN.md b/DESIGN.md new file mode 100644 index 0000000..b45a437 --- /dev/null +++ b/DESIGN.md @@ -0,0 +1,36 @@ +# Схема и транзакционные границы + +Клиент → HTTP API → PostgreSQL. Все данные и сессии — в PostgreSQL. + +- users: UUID PK, UNIQUE username, Argon2id hash, display_name, created_at. +- chats: UUID PK, title, created_at. +- memberships: PK(chat_id,user_id), FK на users/chats; индекс(user_id,chat_id). +- messages: UUID PK, FK chat/sender и составной FK на membership; + text, created_at; B-tree(chat_id,created_at,id). +- sessions: SHA-256 случайного токена как PK, FK user_id, абсолютный expires_at. + SHA-256 применяется только к случайному токену, пароли защищает Argon2id. +- schema_migrations: имя файла и SHA-256 SQL, applied_at. Уже применённый файл + изменять нельзя; следующая версия — новый SQL-файл. + +Создание чата и всех memberships — одна транзакция. Неизвестный участник +вызывает FK violation и откат, включая уже вставленные строки. Регистрация +опирается на UNIQUE, поэтому конкурентный проигравший получает 409. +Вставка сообщения, создание/удаление сессии — отдельные транзакции. +HTTP 201/204 отправляется только после выхода из connection() и COMMIT. +PostgreSQL fsync/synchronous_commit остаются по умолчанию включены. + +Параметризованные SQL; pool 1–8 соединений, ожидание 2 s, очередь до 32; +connect 2 s, statement 2.5 s, lock 1.5 s. Ошибка зависимости → 503 без SQL +и credentials. Readiness зависит от PostgreSQL, liveness — только от API. + +Проверка Bearer и expiry всегда в PostgreSQL. Logout удаляет сессию в БД. +Перезапуск API не меняет токен и срок сессии; volume сохраняет строки БД. +Redis для уровня 3 не используется. + +История: WHERE chat_id=? AND (created_at,id)>(?,?) ORDER BY created_at,id +LIMIT limit+1. Cursor содержит chat UUID, timestamp и message UUID, кодированные +base64url; подделка cursor не заменяет membership-проверку. Список чатов +аналогичен и привязан к пользователю. Уровень изоляции READ COMMITTED: +при неизменной истории нет повторов/потерь; при конкурентных транзакциях поздно +закоммиченная запись с ключом раньше cursor может быть пропущена. Snapshot +между HTTP-страницами не обещается; UTC server clock не является уникальным ID. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..899fae5 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,14 @@ +FROM python:3.12.9-slim-bookworm +ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 +WORKDIR /app +COPY requirements.txt ./ +RUN pip install --no-cache-dir -r requirements.txt && useradd --uid 10001 --create-home messenger +COPY app ./app +COPY migrations ./migrations +COPY tests ./tests +COPY contracts ./contracts +COPY lab.json ./ +COPY student-tests ./student-tests +USER messenger +EXPOSE 8080 +CMD ["python", "-m", "app.main"] diff --git a/Makefile b/Makefile index 9ecb223..58abf00 100644 --- a/Makefile +++ b/Makefile @@ -24,3 +24,14 @@ 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) + +.PHONY: test-student test-expiry verify + +test-student: + docker compose --env-file .env exec -T api python -m unittest discover -s student-tests -v + +test-expiry: + $(PYTHON) scripts/test_expiry.py + +verify: + $(PYTHON) scripts/verify.py diff --git a/REPORT.md b/REPORT.md index e42f2b0..0a8fb3b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,161 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор: Бахрамов Бахрам, БПИ2303. +- Целевая оценка: **3**. +- Ветка: `solution/bpi2303-bakhramov`. +- Commit/PR: заполняются после публикации студентом. +- Дата проверки: 29 октября 2026 г. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Git, Python 3.9+, Docker Desktop/Engine и Docker Compose v2+. +Образы: Python 3.12.9-slim-bookworm, PostgreSQL 17.4-bookworm. +Прямые Python-зависимости закреплены в requirements.txt. + +```sh +python3 scripts/bootstrap.py +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait --wait-timeout 120 +curl -i http://localhost:8080/health/ready +make verify +``` + +bootstrap создаёт случайный учебный пароль PostgreSQL и connection URL в +игнорируемой secrets/, создаёт .env. Значения не печатаются, повторный запуск +сохраняет существующие файлы. API читает смонтированные файлы Docker secrets. +PostgreSQL наружу не опубликован; API доступен на 127.0.0.1:8080. При занятом +порте изменить API_PORT в .env и задать тестам BASE_URL через окружение. + +Миграции автоматически применяются перед стартом API. Повторный ручной запуск: + +```sh +docker compose exec -T api python -m app.migrate +``` + +Проверки по отдельности: + +```sh +make check +make test +make test-student +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-expiry +``` + +`make verify` выполняет эти проверки и сохраняет вывод в evidence/. +Persistence-тест перезапускает API и PostgreSQL, не удаляя volumes. Expiry-тест +временно пересоздаёт API с SESSION_TTL_SECONDS=2, затем восстанавливает обычную +конфигурацию. Обычный TTL — 3600 s, для smoke/persistence требуется минимум 300 s. +Выполнять проверки на учебном стенде без параллельной работы. + +Дополнительная полная проверка контракта: + +```sh +python3 -m venv .venv +.venv/bin/python -m pip install -r requirements-dev.txt +make validate PYTHON=.venv/bin/python +``` + +Остановка с сохранением данных: `docker compose --env-file .env down`. +**Намеренное удаление всех учебных данных:** `docker compose --env-file .env down --volumes`. +Удаление volumes не используется при проверке сохранности. Не заменять пароль +в secrets/ при сохранённом volume БД: POSTGRES_PASSWORD_FILE задаёт его при +первичной инициализации, а не при каждом запуске. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент → HTTP API → PostgreSQL с именованным volume. Redis не используется. +Подробная схема — [DESIGN.md](DESIGN.md), SQL — migrations/001_initial.sql. + +Из собственной lab1 перенесены HTTP-обработчик, валидация, JSON-ошибки, +пагинация и graceful shutdown. In-memory-хранилище заменено PostgreSQL. +Сохранены пользователи, чаты, членство и сообщения. Переход lab2: +регистрация требует password, создание сессии использует Basic, остальные +защищённые операции — Bearer; X-User-Id доступа не даёт. + +Таблицы: users, chats, memberships, messages, sessions. UUID — первичные ключи, +есть внешние ключи, UNIQUE username, составной PK membership и индекс истории. +Создание чата и участников — одна транзакция: при неизвестном участнике FK +вызывает откат всех вставок. Ответ на запись отправляется после COMMIT. +Параметризованные запросы, ограниченный connection pool и таймауты. + +Пароли: Argon2id, time_cost=3, memory_cost=65536 KiB, parallelism=2; +случайную соль создаёт библиотека. UTF-8 пароль 12–128 символов, включая двоеточие. +Сессия: secrets.token_urlsafe(32), 256 бит энтропии; в БД сохраняется SHA-256 +случайного токена, user_id и абсолютный expires_at. SHA-256 не используется +для паролей. При каждом защищённом запросе проверяются сессия и срок по часам +БД. Logout удаляет строку, повторное использование даёт 401. При рестарте срок +не продлевается, действующие сессии остаются в PostgreSQL. + +Миграции версионированы: schema_migrations хранит имя и checksum файла; +advisory lock защищает от параллельного запуска, вся миграция транзакционна. +Повтор не создаёт дубли; изменение применённого SQL обнаруживается. + +Настройки из .env.example: APP_HOST/APP_PORT/APP_ENV заданы в Compose; +SESSION_TTL_SECONDS — из .env; DATABASE_URL_FILE указывает на Docker secret; +SESSION_STORE=postgres. CACHE_URL_FILE не используется на уровне 3. +Дополнительно API_PORT задаёт порт хоста, DB_POOL_SIZE — размер pool (по умолчанию 8). ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +Публичные tests/ и contracts/, README задания сохранены. Результаты формирует +scripts/verify.py; он сохраняет stdout без credentials и сессионных токенов. -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Критерий | Команда / сценарий | Наблюдение | Доказательство | +| --- | --- | --- | --- | +| Целостность skeleton | make check | offline structure PASS | evidence/check.txt | +| Минимум lab1 и новая аутентификация | make test | пользователи, чат, Unicode-сообщения, история, доступ и logout | evidence/smoke.txt | +| PostgreSQL, ограничения, KDF | make test-student | Argon2id в БД; один 201 и три 409 при гонке username | evidence/integration.txt | +| Атомарность создания чата | test_rollback_after_partial_chat_insert | неизвестный member → 400; строки чата после отката нет | evidence/integration.txt | +| Миграции с нуля и повторно | bootstrap; test_migrations_are_repeatable | схема создана; повторные миграции не меняют счётчики | evidence/integration.txt | +| Неверные credentials, Bearer, отзыв | make test; собственные тесты | неверный пароль, X-User-Id и Basic на бизнес-API → 401; logout отзывает токен | evidence/smoke.txt; evidence/integration.txt | +| Данные и сессии переживают рестарт | make test-persistence ACTION_SCRIPT=scripts/restart.sh | прежний токен читает прежние данные | evidence/persistence.txt | +| Реальный перезапуск всех компонентов | scripts/verify.py | StartedAt изменился у API и PostgreSQL | evidence/restart-containers.json | +| Срок жизни сессии | make test-expiry | TTL=2: сначала 200, после 2.3 s — 401 | evidence/expiry.txt | +| OpenAPI | make validate PYTHON=.venv/bin/python | полная валидация контракта PASS | evidence/openapi.txt | + +Фактический прогон 29.10.2026: make check — PASS; make test — PASS; +6 собственных тестов — OK (0.685 s); persistence — PASS; StartedAt API и +PostgreSQL изменился; TTL=2 — PASS, обычная конфигурация восстановлена; +полная OpenAPI-валидация — PASS. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Проверяется гипотеза: данные и действующая сессия хранятся вне памяти API и +сохраняются после остановки/запуска API и БД. Публичный persistence-тест создаёт +синтетических пользователей, чат, сообщение и сессию; вызывает restart.sh; +после ready читает те же данные прежним токеном. verify.py сравнивает StartedAt +контейнеров до/после, подтверждая реальность перезапуска. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Воздействие | Ожидаемый результат | Команда / сохранённый результат | +| --- | --- | --- | +| Перезапуск API и PostgreSQL | сессия и сообщение сохранились, volumes не удалены | make test-persistence; evidence/persistence.txt | +| Истечение короткой сессии | запрос до expiry проходит, после — 401 | make test-expiry; evidence/expiry.txt | +| Неизвестный участник при создании чата | полный rollback, нет частично созданного чата | make test-student; evidence/integration.txt | + +Стенд проверки: Apple M4/arm64, Docker VM с 10 CPU и около 7.75 GiB RAM. +Это функциональные проверки одного локального стенда, не нагрузочное +исследование. RPS/p95/p99 без измерения не заявлены. Подтверждается сохранность +при штатном рестарте, а не при потере диска или удалении volume. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Реализован уровень 3. Redis, HA, backup и исследовательские треки не заявлены. +HTTP — только localhost и синтетические данные. Один PostgreSQL не защищает +от потери host/volume. ThreadingHTTPServer — учебный сервер; pool БД ограничен, +но общее число HTTP-потоков не ограничено. Нет межстраничного snapshot истории: +при конкурентных транзакциях поздний COMMIT с ключом раньше cursor может +не попасть в продолжение. Истёкшие сессии нужно периодически удалять из БД. + +## Источники и использование ИИ + +- README.md, contracts/openapi.json, contracts/README.md, tests/README.md. +- Собственная lab1: app/server.py, models.py, errors.py, main.py из папки ВП. +- PostgreSQL: https://www.postgresql.org/docs/17/tutorial-transactions.html +- Psycopg pool: https://www.psycopg.org/psycopg3/docs/advanced/pool.html +- Argon2-cffi: https://argon2-cffi.readthedocs.io/en/stable/howto.html +- Basic: https://www.rfc-editor.org/rfc/rfc7617 + +OpenAI Codex использован для переноса lab1, реализации PostgreSQL, сессий, +Compose, тестов и документации, проведения проверок. Пояснения для защиты +находятся в DEFENSE.md. diff --git a/SUBMISSION.md b/SUBMISSION.md new file mode 100644 index 0000000..e7488da --- /dev/null +++ b/SUBMISSION.md @@ -0,0 +1,49 @@ +# Публикация решения + +Ветка решения: `solution/bpi2303-bakhramov`. Все команды выполнять из корня +своего клона mtusi2026lab2. Перед отправкой проверить `git status` и diff. + +```sh +git status +git add app migrations student-tests scripts Dockerfile compose.yaml requirements.txt Makefile DESIGN.md REPORT.md SUBMISSION.md DEFENSE.md evidence .github/workflows/application.yml +git diff --cached --stat +git commit -m "ЛР 2: PostgreSQL и сессии" +git push -u origin solution/bpi2303-bakhramov +``` + +В Gitea: свой форк → Запросы на слияние → Новый запрос. +- Назначение: mtusi2026/mtusi2026lab2, ветка master. +- Источник: bahram/mtusi2026lab2, ветка solution/bpi2303-bakhramov. +- Заголовок: **ЛР 2 — БПИ2303 — Бахрамов — на 3**. + +Описание для вставки: + +```markdown +Автор / группа: Бахрамов Бахрам, БПИ2303 +Целевая оценка: 3. Трек 5: не заявлен. + +Перенесены HTTP-обработчик и валидация из собственной lab1. +Добавлены PostgreSQL, версионируемые миграции, Argon2id, Basic-вход, +opaque Bearer-сессии с expiry/logout. + +Запуск: python3 scripts/bootstrap.py && docker compose --env-file .env up -d --build --wait +Проверки: make verify +Отчёт: [REPORT.md](REPORT.md), результаты: [evidence](evidence/). + +Проверены публичный smoke, persistence с перезапуском API и PostgreSQL, +гонка регистрации, rollback, повторный запуск миграций и expiry при TTL=2. + +Ограничения: один PostgreSQL, локальный HTTP, без межстраничного snapshot. +При разработке использован OpenAI Codex; описание помощи и источники в отчёте. + +- [x] Обязательный минимум сохранён с переходом на новую аутентификацию. +- [x] Контракт и публичные проверки не ослаблены. +- [x] make check и make test выполнены, вывод в evidence/. +- [x] Сценарии отказов своего уровня воспроизведены. +- [x] Secrets и приватные данные вне Git. +- [x] README задания сохранён; запуск описан в REPORT.md. +``` + +Отметки проверок соответствуют сохранённому прогону evidence/; при изменении +кода повторить `make verify`. Самостоятельно сливать запрос не требуется: +после создания его проверяет преподаватель. Исправления отправлять в ту же ветку. diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/config.py b/app/config.py new file mode 100644 index 0000000..469f05e --- /dev/null +++ b/app/config.py @@ -0,0 +1,14 @@ +"""Runtime configuration; secret values are read only from mounted files.""" +import os +from pathlib import Path + +APP_HOST = os.getenv('APP_HOST', '0.0.0.0') +APP_PORT = int(os.getenv('APP_PORT', '8080')) +SESSION_TTL_SECONDS = int(os.getenv('SESSION_TTL_SECONDS', '3600')) +POOL_SIZE = int(os.getenv('DB_POOL_SIZE', '8')) +if SESSION_TTL_SECONDS < 1 or not 1 <= POOL_SIZE <= 32: + raise ValueError('Invalid TTL or pool size') + + +def secret(name): + return Path(os.environ[name + '_FILE']).read_text().strip() diff --git a/app/errors.py b/app/errors.py new file mode 100644 index 0000000..1954a90 --- /dev/null +++ b/app/errors.py @@ -0,0 +1,45 @@ +class APIError(Exception): + def __init__(self, code: str, message: str, status_code: int = 400): + super().__init__(message) + self.code = code + self.message = message + self.status_code = status_code + + def to_dict(self, request_id: str) -> dict: + return { + "error": { + "code": self.code, + "message": self.message, + "request_id": request_id, + } + } + + +class BadRequestError(APIError): + def __init__(self, message: str = "Invalid request"): + super().__init__(code="invalid_request", message=message, status_code=400) + + +class UnauthorizedError(APIError): + def __init__(self, message: str = "Unauthorized"): + super().__init__(code="unauthorized", message=message, status_code=401) + + +class NotFoundError(APIError): + def __init__(self, message: str = "Object not found"): + super().__init__(code="not_found", message=message, status_code=404) + + +class ConflictError(APIError): + def __init__(self, message: str = "Conflict"): + super().__init__(code="conflict", message=message, status_code=409) + + +class UnavailableError(APIError): + def __init__(self, message: str = "Service unavailable"): + super().__init__(code="unavailable", message=message, status_code=503) + + +class InternalError(APIError): + def __init__(self, message: str = "Internal server error"): + super().__init__(code="internal_error", message=message, status_code=500) diff --git a/app/main.py b/app/main.py new file mode 100644 index 0000000..ca8ae8c --- /dev/null +++ b/app/main.py @@ -0,0 +1,53 @@ +import logging +import signal +import sys +import threading +from pathlib import Path + +# Ensure root directory is in sys.path +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) + +from app.config import APP_HOST, APP_PORT +from app.server import MessengerServer +from app.migrate import migrate + +logging.basicConfig( + level=logging.INFO, + format="%(asctime)s [%(levelname)s] %(name)s: %(message)s", + stream=sys.stdout, +) +logger = logging.getLogger("messenger") + + +def main(): + migrate() + server = MessengerServer((APP_HOST, APP_PORT)) + logger.info("Starting MTUSI Messenger server on %s:%d", APP_HOST, APP_PORT) + + def handle_signal(sig_num, frame): + sig_name = signal.Signals(sig_num).name + logger.info("Received %s, initiating graceful shutdown...", sig_name) + server.is_shutting_down = True + + def shutdown_thread(): + server.shutdown() + server.server_close() + logger.info("Server stopped cleanly.") + + threading.Thread(target=shutdown_thread, daemon=True).start() + + signal.signal(signal.SIGTERM, handle_signal) + signal.signal(signal.SIGINT, handle_signal) + + try: + server.serve_forever() + except (KeyboardInterrupt, SystemExit): + logger.info("Server exiting...") + finally: + server.server_close() + server.storage.close() + logger.info("Shutdown completed.") + + +if __name__ == "__main__": + main() diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 0000000..e4a80dd --- /dev/null +++ b/app/migrate.py @@ -0,0 +1,28 @@ +"""Transactional, versioned SQL migrations protected by a database advisory lock.""" +import hashlib +from pathlib import Path +import psycopg +from app.config import secret + + +def migrate(): + with psycopg.connect(secret('DATABASE_URL'), connect_timeout=3) as conn: + conn.execute('SELECT pg_advisory_xact_lock(202602)') + conn.execute('''CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, checksum text NOT NULL, + applied_at timestamptz NOT NULL DEFAULT clock_timestamp())''') + for path in sorted((Path(__file__).resolve().parents[1] / 'migrations').glob('*.sql')): + sql = path.read_text() + checksum = hashlib.sha256(sql.encode()).hexdigest() + row = conn.execute('SELECT checksum FROM schema_migrations WHERE version=%s', (path.name,)).fetchone() + if row: + if row[0] != checksum: + raise RuntimeError('Applied migration has changed: ' + path.name) + continue + conn.execute(sql) + conn.execute('INSERT INTO schema_migrations(version, checksum) VALUES (%s,%s)', (path.name, checksum)) + print('Applied migration ' + path.name, flush=True) + + +if __name__ == '__main__': + migrate() diff --git a/app/models.py b/app/models.py new file mode 100644 index 0000000..484534c --- /dev/null +++ b/app/models.py @@ -0,0 +1,171 @@ +import base64 +import datetime as dt +import json +import re +import uuid +from typing import Any, Dict, List, Optional, Tuple +from app.errors import APIError, BadRequestError + +USERNAME_REGEX = re.compile(r'^[a-z0-9_]{3,32}$') + + +def now_utc_z() -> str: + """Return current server time in RFC 3339 UTC format ending with Z.""" + return dt.datetime.now(dt.timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%fZ') + + +def parse_rfc3339(value: str) -> dt.datetime: + """Parse RFC 3339 UTC timestamp ending with Z.""" + if not isinstance(value, str) or not value.endswith('Z'): + raise ValueError("Timestamp must be UTC ending with Z") + return dt.datetime.fromisoformat(value[:-1] + '+00:00') + + +def validate_uuid(value: Any, field_name: str = "id") -> str: + if not isinstance(value, str): + raise BadRequestError(f"{field_name} must be a string") + try: + parsed = uuid.UUID(value) + except (ValueError, TypeError, AttributeError): + raise BadRequestError(f"{field_name} must be a valid UUID") + return str(parsed) + + +def validate_create_user(body: Any) -> Dict[str, Any]: + if not isinstance(body, dict): + raise BadRequestError("Request body must be a JSON object") + allowed_fields = {'username', 'display_name', 'password'} + if set(body.keys()) != allowed_fields: + extra = set(body.keys()) - allowed_fields + missing = allowed_fields - set(body.keys()) + if missing: + raise BadRequestError(f"Missing required fields: {', '.join(missing)}") + if extra: + raise BadRequestError(f"Unexpected fields: {', '.join(extra)}") + + username = body.get('username') + display_name = body.get('display_name') + + if not isinstance(username, str) or not USERNAME_REGEX.fullmatch(username): + raise BadRequestError("username must match ^[a-z0-9_]{3,32}$") + + if not isinstance(display_name, str): + raise BadRequestError("display_name must be a string") + if len(display_name) < 1 or len(display_name) > 100: + raise BadRequestError("display_name length must be between 1 and 100 characters") + if not display_name.strip(): + raise BadRequestError("display_name cannot consist only of whitespace") + + password = body['password'] + if not isinstance(password, str) or not 12 <= len(password) <= 128 or not password.strip(): + raise BadRequestError('password must contain 12–128 nonblank characters') + return {'username': username, 'display_name': display_name, 'password': password} + + +def validate_create_chat(body: Any) -> Dict[str, Any]: + if not isinstance(body, dict): + raise BadRequestError("Request body must be a JSON object") + allowed_fields = {'title', 'member_ids'} + if set(body.keys()) != allowed_fields: + extra = set(body.keys()) - allowed_fields + missing = allowed_fields - set(body.keys()) + if missing: + raise BadRequestError(f"Missing required fields: {', '.join(missing)}") + if extra: + raise BadRequestError(f"Unexpected fields: {', '.join(extra)}") + + title = body.get('title') + member_ids = body.get('member_ids') + + if not isinstance(title, str): + raise BadRequestError("title must be a string") + if len(title) < 1 or len(title) > 100: + raise BadRequestError("title length must be between 1 and 100 characters") + if not title.strip(): + raise BadRequestError("title cannot consist only of whitespace") + + if not isinstance(member_ids, list): + raise BadRequestError("member_ids must be an array") + if len(member_ids) < 1 or len(member_ids) > 100: + raise BadRequestError("member_ids length must be between 1 and 100") + + seen = set() + cleaned_members = [] + for mid in member_ids: + mid_str = validate_uuid(mid, "member_ids element") + if mid_str in seen: + raise BadRequestError(f"Duplicate member_id: {mid_str}") + seen.add(mid_str) + cleaned_members.append(mid_str) + + return {'title': title, 'member_ids': cleaned_members} + + +def validate_create_message(body: Any) -> Dict[str, Any]: + if not isinstance(body, dict): + raise BadRequestError("Request body must be a JSON object") + allowed_fields = {'text'} + if set(body.keys()) != allowed_fields: + extra = set(body.keys()) - allowed_fields + missing = allowed_fields - set(body.keys()) + if missing: + raise BadRequestError(f"Missing required fields: {', '.join(missing)}") + if extra: + raise BadRequestError(f"Unexpected fields: {', '.join(extra)}") + + text = body.get('text') + if not isinstance(text, str): + raise BadRequestError("text must be a string") + if len(text) < 1 or len(text) > 4000: + raise BadRequestError("text length must be between 1 and 4000 characters") + if not text.strip(): + raise BadRequestError("text cannot consist only of whitespace") + + return {'text': text} + + +def parse_limit(limit_param: Optional[str]) -> int: + if limit_param is None: + return 50 + try: + limit = int(limit_param) + except (ValueError, TypeError): + raise BadRequestError("limit must be an integer") + if limit < 1 or limit > 100: + raise BadRequestError("limit must be between 1 and 100") + return limit + + +def encode_cursor(created_at: str, item_id: str, resource_type: str, chat_id: Optional[str] = None) -> str: + data = { + 't': created_at, + 'id': item_id, + 'type': resource_type, + } + if chat_id is not None: + data['cid'] = chat_id + raw = json.dumps(data, separators=(',', ':')).encode('utf-8') + return base64.urlsafe_b64encode(raw).decode('ascii') + + +def decode_cursor(cursor_str: str, expected_type: str, expected_chat_id: Optional[str] = None) -> Tuple[dt.datetime, int]: + try: + if len(cursor_str) > 2048: + raise ValueError + raw = base64.b64decode(cursor_str.encode('ascii'), altchars=b'-_', validate=True) + data = json.loads(raw.decode('utf-8')) + if not isinstance(data, dict): + raise ValueError + if data.get('type') != expected_type: + raise BadRequestError("Cursor does not match resource type") + if expected_chat_id is not None and data.get('cid') != expected_chat_id: + raise BadRequestError("Cursor belongs to another chat") + t = parse_rfc3339(data['t']) + if t.utcoffset() != dt.timedelta(0): + raise ValueError + u_int = uuid.UUID(data['id']).int + return t, u_int + except APIError: + raise + except Exception: + raise BadRequestError("Invalid cursor format") diff --git a/app/server.py b/app/server.py new file mode 100644 index 0000000..95b89c6 --- /dev/null +++ b/app/server.py @@ -0,0 +1,300 @@ +import base64 +import binascii +import json +import socket + +import psycopg +from psycopg_pool import PoolTimeout, TooManyRequests +import logging +import re +import time +import urllib.parse +import uuid +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from typing import Any, Dict, Optional, Tuple + +from app.errors import ( + APIError, + BadRequestError, + InternalError, + NotFoundError, + UnauthorizedError, + UnavailableError, +) +from app.models import ( + parse_limit, + validate_create_chat, + validate_create_message, + validate_create_user, + validate_uuid, +) +from app.storage import PostgresStorage + +logger = logging.getLogger("messenger") + +CHAT_MESSAGES_PATTERN = re.compile(r"^/api/v1/chats/([^/]+)/messages$") +CHAT_DETAIL_PATTERN = re.compile(r"^/api/v1/chats/([^/]+)$") + + +class MessengerHandler(BaseHTTPRequestHandler): + server_version = "MTUSI-Messenger/1.0" + + @property + def storage(self) -> PostgresStorage: + return self.server.storage # type: ignore + + @property + def is_shutting_down(self) -> bool: + return getattr(self.server, "is_shutting_down", False) + + def log_message(self, format: str, *args: Any): + # Suppress default BaseHTTPRequestHandler noisy log + pass + + def _get_request_id(self) -> str: + return str(uuid.uuid4()) + + def setup(self): + super().setup() + self.connection.settimeout(10) + + def _send_json(self, status_code: int, data: Optional[Dict[str, Any]], request_id: str): + body = b"" + if data is not None and status_code != 204: + body = json.dumps(data, ensure_ascii=False).encode("utf-8") + + self.send_response(status_code) + self.send_header("Content-Type", "application/json") + self.send_header("Content-Length", str(len(body))) + self.send_header("X-Request-Id", request_id) + if status_code == 401: + challenge = ('Basic realm="messenger", charset="UTF-8"' if + urllib.parse.urlparse(self.path).path == '/api/v1/auth/sessions' + else 'Bearer realm="messenger"') + self.send_header('WWW-Authenticate', challenge) + self.end_headers() + if body: + self.wfile.write(body) + + def _send_error(self, err: APIError, request_id: str): + payload = err.to_dict(request_id) + self._send_json(err.status_code, payload, request_id) + + def _read_json_body(self) -> Any: + if self.headers.get('Transfer-Encoding'): + raise BadRequestError('Transfer-Encoding is not supported') + if self.headers.get_content_type() != 'application/json': + raise APIError('unsupported_media_type', 'Expected application/json', 415) + content_length_header = self.headers.get("Content-Length") + if not content_length_header: + raise BadRequestError("Missing request body") + try: + content_length = int(content_length_header) + except (ValueError, TypeError): + raise BadRequestError("Invalid Content-Length header") + if content_length < 0 or content_length > 10 * 1024 * 1024: + raise BadRequestError("Payload size invalid") + + raw_data = self.rfile.read(content_length) + if not raw_data: + raise BadRequestError("Empty request body") + + try: + body = json.loads(raw_data.decode("utf-8")) + # Reject unpaired surrogates before a driver/KDF tries to encode them. + json.dumps(body, ensure_ascii=False).encode('utf-8') + return body + except (ValueError, UnicodeError): + raise BadRequestError("Malformed JSON in request body") + + def _bearer(self): + parts = self.headers.get('Authorization', '').split() + if len(parts) != 2 or parts[0].lower() != 'bearer' or len(parts[1]) > 512: + raise UnauthorizedError() + return parts[1] + + def _authenticate_user(self): + return self.storage.authenticate(self._bearer()) + + def _login(self): + parts = self.headers.get('Authorization', '').split() + if len(parts) != 2 or parts[0].lower() != 'basic' or len(parts[1]) > 2048: + raise UnauthorizedError('Invalid credentials') + try: + credential = base64.b64decode(parts[1], validate=True).decode('utf-8') + username, password = credential.split(':', 1) + if not re.fullmatch(r'[a-z0-9_]{3,32}', username) or not 12 <= len(password) <= 128: + raise ValueError + except (ValueError, UnicodeError, binascii.Error): + raise UnauthorizedError('Invalid credentials') from None + if self.headers.get('Transfer-Encoding') or self.headers.get('Content-Length', '0') != '0': + raise BadRequestError('Session creation has no body') + return self.storage.login(username, password) + + def do_PUT(self): + self._handle_request("PUT") + + def do_PATCH(self): + self._handle_request("PATCH") + + def do_OPTIONS(self): + self._handle_request("OPTIONS") + + def do_DELETE(self): + self._handle_request("DELETE") + + def do_GET(self): + self._handle_request("GET") + + def do_POST(self): + self._handle_request("POST") + + def _handle_request(self, method: str): + start_time = time.monotonic() + request_id = self._get_request_id() + parsed_url = urllib.parse.urlparse(self.path) + path = parsed_url.path + query = urllib.parse.parse_qs(parsed_url.query, keep_blank_values=True) + + status_code = 200 + try: + if self.is_shutting_down and not path.startswith("/health/"): + raise UnavailableError("Server is shutting down") + + # Route dispatcher + if method == "GET" and path == "/health/live": + self._send_json(200, {"status": "ok"}, request_id) + status_code = 200 + + elif method == "GET" and path == "/health/ready": + if self.is_shutting_down: + raise UnavailableError("Server is shutting down") + self.storage.ready() + self._send_json(200, {"status": "ok"}, request_id) + status_code = 200 + + elif method == "POST" and path == "/api/v1/users": + body = self._read_json_body() + validated = validate_create_user(body) + user = self.storage.create_user(**validated) + self._send_json(201, user, request_id) + status_code = 201 + + elif method == 'POST' and path == '/api/v1/auth/sessions': + self._send_json(201, self._login(), request_id) + status_code = 201 + + elif method == 'DELETE' and path == '/api/v1/auth/sessions/current': + self.storage.logout(self._bearer()) + self._send_json(204, None, request_id) + status_code = 204 + + elif method == "GET" and path == "/api/v1/users/me": + actor = self._authenticate_user() + self._send_json(200, actor, request_id) + status_code = 200 + + elif method == "POST" and path == "/api/v1/chats": + actor = self._authenticate_user() + body = self._read_json_body() + validated = validate_create_chat(body) + chat = self.storage.create_chat( + creator_id=actor["id"], + title=validated["title"], + member_ids=validated["member_ids"], + ) + self._send_json(201, chat, request_id) + status_code = 201 + + elif method == "GET" and path == "/api/v1/chats": + actor = self._authenticate_user() + limit_val = query.get("limit", [None])[0] + cursor_val = query.get("cursor", [None])[0] + limit = parse_limit(limit_val) + result = self.storage.list_chats(actor["id"], limit=limit, cursor=cursor_val) + self._send_json(200, result, request_id) + status_code = 200 + + else: + # Check regex routes + match_messages = CHAT_MESSAGES_PATTERN.match(path) + match_chat = CHAT_DETAIL_PATTERN.match(path) + + if match_messages: + raw_chat_id = match_messages.group(1) + actor = self._authenticate_user() + chat_id = validate_uuid(raw_chat_id, "chat_id") + + if method == "POST": + body = self._read_json_body() + validated = validate_create_message(body) + msg = self.storage.create_message( + chat_id=chat_id, + sender_id=actor["id"], + text=validated["text"], + ) + self._send_json(201, msg, request_id) + status_code = 201 + elif method == "GET": + limit_val = query.get("limit", [None])[0] + cursor_val = query.get("cursor", [None])[0] + limit = parse_limit(limit_val) + result = self.storage.list_messages( + user_id=actor["id"], + chat_id=chat_id, + limit=limit, + cursor=cursor_val, + ) + self._send_json(200, result, request_id) + status_code = 200 + else: + raise NotFoundError("Endpoint not found") + + elif match_chat: + raw_chat_id = match_chat.group(1) + actor = self._authenticate_user() + chat_id = validate_uuid(raw_chat_id, "chat_id") + + if method == "GET": + chat = self.storage.get_chat(user_id=actor["id"], chat_id=chat_id) + self._send_json(200, chat, request_id) + status_code = 200 + else: + raise NotFoundError("Endpoint not found") + else: + raise NotFoundError(f"Route not found: {method} {path}") + + except APIError as err: + status_code = err.status_code + self._send_error(err, request_id) + except (psycopg.OperationalError, psycopg.InterfaceError, psycopg.errors.QueryCanceled, + psycopg.errors.LockNotAvailable, PoolTimeout, TooManyRequests): + status_code = 503 + self._send_error(UnavailableError(), request_id) + except (socket.timeout, ConnectionError): + status_code = 408 + self.close_connection = True + except Exception as exc: + status_code = 500 + logger.error("Unhandled exception type: %s", type(exc).__name__) + self._send_error(InternalError("Internal server error"), request_id) + finally: + elapsed_ms = (time.monotonic() - start_time) * 1000 + # Safe structured log without payload content + logger.info( + "%s %s %d %.2fms req_id=%s", + method, + path, + status_code, + elapsed_ms, + request_id, + ) + + +class MessengerServer(ThreadingHTTPServer): + daemon_threads = True + + def __init__(self, server_address: Tuple[str, int], storage: Optional[PostgresStorage] = None): + super().__init__(server_address, MessengerHandler) + self.storage = storage or PostgresStorage() + self.is_shutting_down = False diff --git a/app/storage.py b/app/storage.py new file mode 100644 index 0000000..7aaeef2 --- /dev/null +++ b/app/storage.py @@ -0,0 +1,172 @@ +"""Persistent users, chats, messages and sessions in PostgreSQL.""" +import datetime as dt +import hashlib +import secrets +import uuid + +import psycopg +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHashError + +from app.config import secret, POOL_SIZE, SESSION_TTL_SECONDS +from app.errors import BadRequestError, ConflictError, NotFoundError, UnauthorizedError +from app.models import decode_cursor, encode_cursor + + +def public(row): + return {key: (str(value) if isinstance(value, uuid.UUID) else + value.isoformat(timespec='microseconds').replace('+00:00', 'Z') + if isinstance(value, dt.datetime) else value) + for key, value in row.items() if key != 'password_hash'} + + +def token_hash(token): + return hashlib.sha256(token.encode()).hexdigest() + + +class PostgresStorage: + def __init__(self): + self.pool = ConnectionPool( + secret('DATABASE_URL'), min_size=1, max_size=POOL_SIZE, timeout=2, + max_waiting=32, reconnect_timeout=3, + kwargs={'connect_timeout': 2, 'row_factory': dict_row, + 'options': '-c statement_timeout=2500 -c lock_timeout=1500 -c timezone=UTC'}, + check=ConnectionPool.check_connection, + ) + self.pool.wait(timeout=15) + self.hasher = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=2) + self.dummy_hash = self.hasher.hash(secrets.token_urlsafe(32)) + + def close(self): + self.pool.close() + + def ready(self): + with self.pool.connection() as conn: + conn.execute('SELECT 1') + + def create_user(self, username, display_name, password): + password_hash = self.hasher.hash(password) + try: + with self.pool.connection() as conn: + row = conn.execute('''INSERT INTO users(id, username, display_name, password_hash) + VALUES (%s,%s,%s,%s) RETURNING id, username, display_name, created_at''', + (uuid.uuid4(), username, display_name, password_hash)).fetchone() + return public(row) + except psycopg.errors.UniqueViolation: + raise ConflictError('Username is already taken') from None + + def get_user(self, user_id): + with self.pool.connection() as conn: + row = conn.execute('SELECT id,username,display_name,created_at FROM users WHERE id=%s', (user_id,)).fetchone() + return public(row) if row else None + + def login(self, username, password): + with self.pool.connection() as conn: + row = conn.execute('SELECT * FROM users WHERE username=%s', (username,)).fetchone() + try: + self.hasher.verify(row['password_hash'] if row else self.dummy_hash, password) + except (VerifyMismatchError, VerificationError, InvalidHashError): + raise UnauthorizedError('Invalid credentials') from None + if not row: + raise UnauthorizedError('Invalid credentials') + token = secrets.token_urlsafe(32) # 256 random bits; never persist/log the raw token. + with self.pool.connection() as conn: + session = conn.execute('''INSERT INTO sessions(token_hash,user_id,expires_at) + VALUES (%s,%s,clock_timestamp() + %s * interval '1 second') RETURNING expires_at''', + (token_hash(token), row['id'], SESSION_TTL_SECONDS)).fetchone() + return {'token': token, 'token_type': 'Bearer', + 'expires_at': public(session)['expires_at'], 'user': public(row)} + + def authenticate(self, token): + # Check expiry against the database clock on every protected request. + with self.pool.connection() as conn: + row = conn.execute('''SELECT user_id FROM sessions + WHERE token_hash=%s AND expires_at > clock_timestamp()''', (token_hash(token),)).fetchone() + if not row: + raise UnauthorizedError() + user = self.get_user(row['user_id']) + if not user: + raise UnauthorizedError() + return user + + def logout(self, token): + with self.pool.connection() as conn: + row = conn.execute('''DELETE FROM sessions WHERE token_hash=%s + AND expires_at > clock_timestamp() RETURNING user_id''', (token_hash(token),)).fetchone() + if not row: + raise UnauthorizedError() + + @staticmethod + def _chat(conn, chat_id): + row = conn.execute('SELECT * FROM chats WHERE id=%s', (chat_id,)).fetchone() + result = public(row) + result['member_ids'] = [str(r['user_id']) for r in conn.execute( + 'SELECT user_id FROM memberships WHERE chat_id=%s ORDER BY user_id', (chat_id,))] + return result + + @staticmethod + def _access(conn, user_id, chat_id): + if not conn.execute('SELECT 1 FROM memberships WHERE chat_id=%s AND user_id=%s', + (chat_id, user_id)).fetchone(): + raise NotFoundError('Chat not found') + + def create_chat(self, creator_id, title, member_ids): + if creator_id not in member_ids: + raise BadRequestError('Creator must be included in member_ids') + try: + with self.pool.connection() as conn: + chat_id = uuid.uuid4() + conn.execute('INSERT INTO chats(id,title) VALUES (%s,%s)', (chat_id, title)) + with conn.cursor() as cur: + cur.executemany('INSERT INTO memberships(chat_id,user_id) VALUES (%s,%s)', + [(chat_id, user_id) for user_id in member_ids]) + chat = self._chat(conn, chat_id) + return chat + except psycopg.errors.ForeignKeyViolation: + # Exiting connection() rolls back chat and every already inserted member. + raise BadRequestError('Unknown participant') from None + + def get_chat(self, user_id, chat_id): + with self.pool.connection() as conn: + self._access(conn, user_id, chat_id) + return self._chat(conn, chat_id) + + def list_chats(self, user_id, limit=50, cursor=None): + params = [user_id] + condition = '' + if cursor is not None: + stamp, item_id = decode_cursor(cursor, 'chat', user_id) + condition = ' AND (c.created_at,c.id) > (%s,%s)' + params.extend([stamp, uuid.UUID(int=item_id)]) + params.append(limit + 1) + with self.pool.connection() as conn: + rows = conn.execute('''SELECT c.* FROM chats c JOIN memberships m ON m.chat_id=c.id + WHERE m.user_id=%s''' + condition + ' ORDER BY c.created_at,c.id LIMIT %s', params).fetchall() + items = [self._chat(conn, row['id']) for row in rows[:limit]] + next_cursor = encode_cursor(items[-1]['created_at'], items[-1]['id'], 'chat', user_id) if len(rows) > limit else None + return {'items': items, 'next_cursor': next_cursor} + + def create_message(self, chat_id, sender_id, text): + with self.pool.connection() as conn: + self._access(conn, sender_id, chat_id) + row = conn.execute('''INSERT INTO messages(id,chat_id,sender_id,text) + VALUES (%s,%s,%s,%s) RETURNING *''', (uuid.uuid4(), chat_id, sender_id, text)).fetchone() + return public(row) + + def list_messages(self, user_id, chat_id, limit=50, cursor=None): + params = [chat_id] + condition = '' + if cursor is not None: + stamp, item_id = decode_cursor(cursor, 'message', chat_id) + condition = ' AND (created_at,id) > (%s,%s)' + params.extend([stamp, uuid.UUID(int=item_id)]) + params.append(limit + 1) + with self.pool.connection() as conn: + self._access(conn, user_id, chat_id) + rows = conn.execute('SELECT * FROM messages WHERE chat_id=%s' + condition + + ' ORDER BY created_at,id LIMIT %s', params).fetchall() + items = [public(row) for row in rows[:limit]] + next_cursor = encode_cursor(items[-1]['created_at'], items[-1]['id'], 'message', chat_id) if len(rows) > limit else None + return {'items': items, 'next_cursor': next_cursor} diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..42c5cdb --- /dev/null +++ b/compose.yaml @@ -0,0 +1,48 @@ +name: mtusi-lab2 +services: + postgres: + image: postgres:17.4-bookworm + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: [postgres_password] + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: [CMD-SHELL, 'pg_isready -U messenger -d messenger'] + interval: 2s + timeout: 3s + retries: 30 + restart: unless-stopped + api: + build: . + environment: + APP_HOST: 0.0.0.0 + APP_PORT: '8080' + APP_ENV: lab + DATABASE_URL_FILE: /run/secrets/database_url + SESSION_STORE: postgres + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DB_POOL_SIZE: ${DB_POOL_SIZE:-8} + secrets: [database_url] + ports: + - '127.0.0.1:${API_PORT:-8080}:8080' + depends_on: + postgres: + condition: service_healthy + healthcheck: + test: [CMD, python, -c, "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=4)"] + interval: 2s + timeout: 5s + retries: 30 + init: true + stop_grace_period: 15s + restart: unless-stopped +volumes: + postgres_data: +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 0000000..9a55330 --- /dev/null +++ b/evidence/check.txt @@ -0,0 +1,2 @@ +python3 scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. diff --git a/evidence/expiry.txt b/evidence/expiry.txt new file mode 100644 index 0000000..cfcfcc3 --- /dev/null +++ b/evidence/expiry.txt @@ -0,0 +1,10 @@ + Container mtusi-lab2-api-1 Recreate + Container mtusi-lab2-api-1 Recreated + Container mtusi-lab2-api-1 Starting + Container mtusi-lab2-api-1 Started +PASS SESSION_TTL_SECONDS=2: session accepted before expiry and rejected afterwards + Container mtusi-lab2-api-1 Recreate + Container mtusi-lab2-api-1 Recreated + Container mtusi-lab2-api-1 Starting + Container mtusi-lab2-api-1 Started +PASS expiry scenario; normal API configuration restored diff --git a/evidence/integration.txt b/evidence/integration.txt new file mode 100644 index 0000000..fa465bf --- /dev/null +++ b/evidence/integration.txt @@ -0,0 +1,11 @@ +test_bad_credentials_and_validation (test_integration.IntegrationTests.test_bad_credentials_and_validation) ... ok +test_history_and_cross_chat_cursor (test_integration.IntegrationTests.test_history_and_cross_chat_cursor) ... ok +test_logout_revokes_session (test_integration.IntegrationTests.test_logout_revokes_session) ... ok +test_migrations_are_repeatable (test_integration.IntegrationTests.test_migrations_are_repeatable) ... ok +test_registration_race_and_password_storage (test_integration.IntegrationTests.test_registration_race_and_password_storage) ... ok +test_rollback_after_partial_chat_insert (test_integration.IntegrationTests.test_rollback_after_partial_chat_insert) ... ok + +---------------------------------------------------------------------- +Ran 6 tests in 0.685s + +OK diff --git a/evidence/openapi.txt b/evidence/openapi.txt new file mode 100644 index 0000000..37e8188 --- /dev/null +++ b/evidence/openapi.txt @@ -0,0 +1,2 @@ +.venv/bin/python scripts/validate_openapi.py +PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested. diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 0000000..793b001 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,3 @@ +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +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-containers.json b/evidence/restart-containers.json new file mode 100644 index 0000000..dc44d5a --- /dev/null +++ b/evidence/restart-containers.json @@ -0,0 +1,22 @@ +{ + "before": { + "api": { + "container_id": "56edea40b5725e2d7cb53b3845e3add8736cd97b0d3aa5d6ed7f3edd60d39490", + "started_at": "2026-10-29T14:14:33.964585083Z" + }, + "postgres": { + "container_id": "06377e012859509c85940553ce08940f53b54784f689bb743a20f2a0e27c9940", + "started_at": "2026-10-29T14:14:31.393036638Z" + } + }, + "after": { + "api": { + "container_id": "56edea40b5725e2d7cb53b3845e3add8736cd97b0d3aa5d6ed7f3edd60d39490", + "started_at": "2026-10-29T14:14:45.403053172Z" + }, + "postgres": { + "container_id": "06377e012859509c85940553ce08940f53b54784f689bb743a20f2a0e27c9940", + "started_at": "2026-10-29T14:14:45.180754422Z" + } + } +} diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 0000000..404a2c6 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 0000000..0898207 --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,36 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100), + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100), + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE TABLE memberships ( + chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users(id), + PRIMARY KEY (chat_id, user_id) +); +CREATE INDEX memberships_by_user ON memberships(user_id, chat_id); +CREATE INDEX chats_history ON chats(created_at, 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 text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + FOREIGN KEY (chat_id, sender_id) REFERENCES memberships(chat_id, user_id) +); +CREATE INDEX messages_history ON messages(chat_id, created_at, id); +CREATE TABLE sessions ( + token_hash text PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + expires_at timestamptz NOT NULL, + CHECK (expires_at > created_at) +); +CREATE INDEX sessions_expiry ON sessions(expires_at); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..222e562 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +psycopg[binary]==3.2.6 +psycopg-pool==3.2.6 +argon2-cffi==23.1.0 diff --git a/scripts/bootstrap.py b/scripts/bootstrap.py new file mode 100644 index 0000000..72682dd --- /dev/null +++ b/scripts/bootstrap.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python3 +"""Create local synthetic credentials once. Never print their values.""" +import os +from pathlib import Path +import secrets + +root = Path(__file__).resolve().parents[1] +os.umask(0o077) +folder = root / 'secrets' +folder.mkdir(exist_ok=True) +password_path = folder / 'postgres_password' +if not password_path.exists(): + password_path.write_text(secrets.token_hex(24)) +password = password_path.read_text().strip() +for name, value in { + 'database_url': 'postgresql://messenger:' + password + '@postgres:5432/messenger', +}.items(): + path = folder / name + if not path.exists(): + path.write_text(value) +# Docker Desktop mounts are read by the non-root API user too. Directory remains private. +for path in folder.iterdir(): + path.chmod(0o444) +env = root / '.env' +if not env.exists(): + env.write_text('API_PORT=8080\nSESSION_TTL_SECONDS=3600\nDB_POOL_SIZE=8\n') +print('Local secrets and .env ready (values hidden; existing files preserved).') diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 0000000..079c74b --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +# All state stores and API; named volumes remain attached. No reseeding. +docker compose --env-file .env restart postgres api diff --git a/scripts/test_expiry.py b/scripts/test_expiry.py new file mode 100644 index 0000000..a284c80 --- /dev/null +++ b/scripts/test_expiry.py @@ -0,0 +1,52 @@ +#!/usr/bin/env python3 +"""Check real session expiry with TTL=2 and restore normal API configuration.""" +import os +from pathlib import Path +import subprocess +import sys +import time + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0,str(ROOT / 'tests')) +from client import Client, Failure, check + +COMPOSE = ['docker','compose','--env-file','.env'] + + +def compose(*args, env=None): + subprocess.run(COMPOSE+list(args),cwd=ROOT,env=env,check=True, + stdout=subprocess.DEVNULL) + + +def ready(c): + deadline=time.monotonic()+60 + while time.monotonic()