Author SHA1 Message Date
Бахрам 641c02ca03 lab2.1 2026-10-29 17:34:55 +03:00
Бахрам c401ece9b1 lab2 2026-10-29 17:16:55 +03:00
30 changed files with 1456 additions and 18 deletions
+23
View File
@@ -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
+28
View File
@@ -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`.
+36
View File
@@ -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.
+14
View File
@@ -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"]
+11
View File
@@ -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
+138 -18
View File
@@ -1,37 +1,157 @@
# Отчёт — лабораторная 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
+50
View File
@@ -0,0 +1,50 @@
# Публикация решения
Ветка решения: `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.
Источники: контракт задания, собственная lab1, документация PostgreSQL,
Psycopg и Argon2-cffi. Подробности в REPORT.md.
- [x] Обязательный минимум сохранён с переходом на новую аутентификацию.
- [x] Контракт и публичные проверки не ослаблены.
- [x] make check и make test выполнены, вывод в evidence/.
- [x] Сценарии отказов своего уровня воспроизведены.
- [x] Secrets и приватные данные вне Git.
- [x] README задания сохранён; запуск описан в REPORT.md.
```
Отметки проверок соответствуют сохранённому прогону evidence/; при изменении
кода повторить `make verify`. Самостоятельно сливать запрос не требуется:
после создания его проверяет преподаватель. Исправления отправлять в ту же ветку.
View File
+14
View File
@@ -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()
+45
View File
@@ -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)
+53
View File
@@ -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()
+28
View File
@@ -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()
+171
View File
@@ -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")
+300
View File
@@ -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
+172
View File
@@ -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}
+48
View File
@@ -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
+2
View File
@@ -0,0 +1,2 @@
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+10
View File
@@ -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
+11
View File
@@ -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
+2
View File
@@ -0,0 +1,2 @@
.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
+3
View File
@@ -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.
+22
View File
@@ -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"
}
}
}
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+36
View File
@@ -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);
+3
View File
@@ -0,0 +1,3 @@
psycopg[binary]==3.2.6
psycopg-pool==3.2.6
argon2-cffi==23.1.0
+27
View File
@@ -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).')
+5
View File
@@ -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
+52
View File
@@ -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()<deadline:
try:
c.call('GET','/health/ready')
return
except Failure:
time.sleep(0.5)
raise AssertionError('Readiness timeout')
def main():
c=Client()
ready(c)
try:
env=dict(os.environ,SESSION_TTL_SECONDS='2')
compose('up','-d','--no-deps','--force-recreate','api',env=env)
ready(c)
short=c.user('expiry')
c.call('GET','/api/v1/users/me',actor=short,schema='User')
time.sleep(2.3)
c.call('GET','/api/v1/users/me',401,actor=short)
c.call('DELETE','/api/v1/auth/sessions/current',401,actor=short)
print('PASS SESSION_TTL_SECONDS=2: session accepted before expiry and rejected afterwards',flush=True)
finally:
compose('up','-d','--no-deps','--force-recreate','api')
ready(c)
print('PASS expiry scenario; normal API configuration restored',flush=True)
if __name__=='__main__':
main()
+50
View File
@@ -0,0 +1,50 @@
#!/usr/bin/env python3
"""Run all lab2 checks and save sanitized evidence. Start Compose first."""
import json
from pathlib import Path
import subprocess
import sys
ROOT = Path(__file__).resolve().parents[1]
COMPOSE = ['docker','compose','--env-file','.env']
def capture(name, args):
result = subprocess.run(args,cwd=ROOT,text=True,stdout=subprocess.PIPE,stderr=subprocess.STDOUT)
(ROOT/'evidence'/name).write_text(result.stdout)
print(result.stdout,end='',flush=True)
if result.returncode:
raise SystemExit(result.returncode)
def snapshot():
ids = subprocess.check_output(COMPOSE+['ps','-q'],cwd=ROOT,text=True).split()
result = {}
for cid in ids:
# Select fields explicitly: full inspect includes private configuration.
fields = subprocess.check_output(['docker','inspect','--format',
'{{ index .Config.Labels "com.docker.compose.service" }}|{{.Id}}|{{.State.StartedAt}}',cid],text=True).strip().split('|')
result[fields[0]]={'container_id':fields[1],'started_at':fields[2]}
return result
def main():
capture('check.txt',['make','check'])
capture('smoke.txt',['make','test'])
capture('integration.txt',COMPOSE+['exec','-T','api','python','-m','unittest','discover','-s','student-tests','-v'])
before = snapshot()
capture('persistence.txt',['make','test-persistence','ACTION_SCRIPT=scripts/restart.sh'])
after = snapshot()
if set(before) != {'api','postgres'} or set(after) != set(before):
raise AssertionError('Expected API and PostgreSQL')
for role in before:
if before[role]['started_at']==after[role]['started_at']:
raise AssertionError(role+' was not restarted')
(ROOT/'evidence'/'restart-containers.json').write_text(json.dumps({'before':before,'after':after},indent=2)+'\n')
print('PASS restart timestamps changed for API and PostgreSQL',flush=True)
capture('expiry.txt',[sys.executable,'scripts/test_expiry.py'])
print('PASS full verification; evidence/ updated',flush=True)
if __name__ == '__main__':
main()
+100
View File
@@ -0,0 +1,100 @@
"""Run inside the API container against the real PostgreSQL stack."""
import base64
from concurrent.futures import ThreadPoolExecutor
import json
from pathlib import Path
import sys
import unittest
from urllib.parse import quote
import uuid
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
import psycopg
from client import Client
from app.config import secret
from app.migrate import migrate
from app.storage import token_hash
class IntegrationTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.c = Client('http://127.0.0.1:8080')
cls.alice, cls.bob, cls.eve, cls.chat = cls.c.bootstrap()
def test_registration_race_and_password_storage(self):
body = {'username': 'race_' + uuid.uuid4().hex[:16], 'display_name': 'Гонка', 'password': 'пароль:🔑' * 16}
def register(_):
return Client('http://127.0.0.1:8080').call('POST', '/api/v1/users', [201,409], body=body)['status']
with ThreadPoolExecutor(max_workers=4) as pool:
codes = list(pool.map(register, range(4)))
self.assertEqual(sorted(codes), [201,409,409,409])
credential = base64.b64encode((body['username'] + ':' + body['password']).encode()).decode()
session = self.c.call('POST','/api/v1/auth/sessions',201,headers={'Authorization': 'Basic ' + credential},schema='Session')['json']
with psycopg.connect(secret('DATABASE_URL')) as conn:
hashed = conn.execute('SELECT password_hash FROM users WHERE username=%s', (body['username'],)).fetchone()[0]
self.assertTrue(hashed.startswith('$argon2id$'))
self.assertNotEqual(hashed, body['password'])
self.assertEqual(len(base64.urlsafe_b64decode(session['token'] + '=')), 32)
stored = conn.execute('SELECT token_hash FROM sessions WHERE token_hash=%s', (token_hash(session['token']),)).fetchone()[0]
self.assertNotEqual(stored, session['token'])
def test_rollback_after_partial_chat_insert(self):
title = 'rollback_' + uuid.uuid4().hex
self.c.call('POST','/api/v1/chats',400,actor=self.alice,
body={'title':title,'member_ids':[self.alice['id'],str(uuid.uuid4())]})
with psycopg.connect(secret('DATABASE_URL')) as conn:
count = conn.execute('SELECT count(*) FROM chats WHERE title=%s',(title,)).fetchone()[0]
self.assertEqual(count,0, 'failed chat creation must roll back inserted chat')
def test_logout_revokes_session(self):
actor = self.c.user('logout')
self.c.call('GET','/api/v1/users/me',actor=actor,schema='User')
self.c.call('DELETE','/api/v1/auth/sessions/current',204,actor=actor)
self.c.call('GET','/api/v1/users/me',401,actor=actor)
self.c.call('DELETE','/api/v1/auth/sessions/current',401,actor=actor)
def test_history_and_cross_chat_cursor(self):
chat = self.c.call('POST','/api/v1/chats',201,actor=self.alice,
body={'title':'Cursor','member_ids':[self.alice['id']]},schema='Chat')['json']
sent = [self.c.message(self.alice,chat,'Строка ' + str(i))['json'] for i in range(5)]
path = '/api/v1/chats/' + chat['id'] + '/messages'
page = self.c.call('GET',path+'?limit=2',actor=self.alice,schema='MessagePage')['json']
received = page['items'][:]
foreign = '/api/v1/chats/' + self.chat['id'] + '/messages?cursor=' + quote(page['next_cursor'],safe='')
self.c.call('GET',foreign,400,actor=self.alice)
while page['next_cursor']:
page = self.c.call('GET',path+'?limit=1&cursor='+quote(page['next_cursor'],safe=''),actor=self.alice,schema='MessagePage')['json']
received.extend(page['items'])
self.assertEqual(sent,received)
for query in ('cursor=broken','cursor=','limit=','limit=101','limit=1.5'):
self.c.call('GET',path+'?'+query,400,actor=self.alice)
self.c.call('GET',path,404,actor=self.eve)
self.c.call('GET','/api/v1/chats/not-a-uuid/messages',401)
def test_migrations_are_repeatable(self):
def counts():
with psycopg.connect(secret('DATABASE_URL')) as conn:
return conn.execute('SELECT (SELECT count(*) FROM schema_migrations), (SELECT count(*) FROM users), (SELECT count(*) FROM chats)').fetchone()
before = counts()
migrate()
migrate()
self.assertEqual(counts(),before)
def test_bad_credentials_and_validation(self):
actor = self.c.user('negative')
for credential in ('!!!',base64.b64encode((actor['registration']['username']+':wrong-password').encode()).decode(),
base64.b64encode(b'unknown_user:wrong-password').decode()):
response = self.c.call('POST','/api/v1/auth/sessions',401,headers={'Authorization':'Basic '+credential})
self.assertEqual(response['json']['error']['message'],'Invalid credentials')
self.c.call('GET','/api/v1/users/me',401,headers={'Authorization':'Bearer not-a-session'})
self.c.call('POST','/api/v1/users',400,raw=b'{broken',headers={'Content-Type':'application/json'})
self.c.call('POST','/api/v1/users',400,body={**actor['registration'],'extra':True})
self.c.call('POST','/api/v1/users',400,body={**actor['registration'],'password':'short'})
self.c.call('POST','/api/v1/users',400,body={**actor['registration'],'username':'bad\n'})
self.c.call('POST','/api/v1/users',400,raw=json.dumps({**actor['registration'],'display_name':'\ud800'}).encode(),headers={'Content-Type':'application/json'})
if __name__ == '__main__':
unittest.main(verbosity=2)