level 3 basics
This commit is contained in:
+9
-2
@@ -3,9 +3,16 @@
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
LOG_LEVEL=info
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Local synthetic database. Use a password without URL reserved characters.
|
||||
# Compose injects DATABASE_URL into the API from these three values.
|
||||
# The password below is a placeholder: change it in the untracked .env.
|
||||
POSTGRES_USER=messenger
|
||||
POSTGRES_PASSWORD=replace-with-a-local-password
|
||||
POSTGRES_DB=messenger
|
||||
# Optional. When set, the API reads the URL from this file instead of DATABASE_URL.
|
||||
# DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
|
||||
@@ -21,6 +21,7 @@ COPY requirements.txt .
|
||||
RUN python -m pip install --no-cache-dir --disable-pip-version-check --root-user-action=ignore -r requirements.txt
|
||||
|
||||
COPY --chown=app:app app ./app
|
||||
COPY --chown=app:app migrations ./migrations
|
||||
COPY --chown=app:app contracts/openapi.json ./contracts/openapi.json
|
||||
|
||||
USER app
|
||||
|
||||
@@ -1,37 +1,75 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: Тимаева М.П. БПИ2302
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: 3
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Использованные источники, библиотеки и помощь ИИ: контракт и README этой лабораторной; PostgreSQL transactions; RFC 7617; библиотеки fastapi, uvicorn, asyncpg 0.32.0, argon2-cffi 25.1.0. Реализацию переноса в PostgreSQL помог собрать агент Cursor.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Нужны Docker и Docker Compose v2. Образы закреплены: `python:3.14.8-slim-bookworm` (digest в Dockerfile) и `postgres:16.10-alpine`.
|
||||
|
||||
```sh
|
||||
cp .env.example .env
|
||||
# В .env замените POSTGRES_PASSWORD на локальный пароль без символов @ : / # ? и пробелов.
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build
|
||||
```
|
||||
|
||||
API читает `DATABASE_URL`, который compose собирает из `POSTGRES_USER`, `POSTGRES_PASSWORD` и `POSTGRES_DB`. Если задан `DATABASE_URL_FILE`, он важнее и файл не логируется. Миграции из `migrations/` применяются при старте API и записываются в `schema_migrations`; повторный старт их не исполняет заново. Пароль БД лежит только в неотслеживаемом `.env`.
|
||||
|
||||
Дождитесь `GET http://127.0.0.1:8080/health/ready` → `200 {"status":"ok"}`. Для smoke и persistence `SESSION_TTL_SECONDS` не меньше 300; в `.env.example` стоит 3600.
|
||||
|
||||
```sh
|
||||
make check
|
||||
make test
|
||||
chmod +x scripts/restart.sh
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
```
|
||||
|
||||
На Windows `python` не может запустить `scripts/restart.sh` через CreateProcess (`WinError 193`). Сам hook — POSIX shell и рассчитан на Linux, WSL или Git Bash с POSIX Python. На этой машине публичный harness был выполнен в контейнере `docker:28-cli` с `python3`, в сети compose и с Docker socket; вызывался тот же `scripts/restart.sh`. Подробности в `evidence/grade3.txt`.
|
||||
|
||||
Остановка без удаления данных: `docker compose --env-file .env stop`. Намеренное удаление учебного volume: `docker compose --env-file .env down -v`.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Клиент ходит в один процесс API. Источник истины — PostgreSQL, named volume `pgdata`. Redis/Valkey нет: действующие сессии лежат в таблице `sessions`.
|
||||
|
||||
Таблицы `migrations/001_init.sql`: `users` (UNIQUE username, FK нет наружу), `sessions` (PK — SHA-256 токена, FK на пользователя, `expires_at`), `chats`, `chat_members` (PK пары, оба FK, `position`), `messages` (FK на чат и отправителя), `schema_migrations`. Индекс `messages_history_idx (chat_id, created_at, id)` обслуживает keyset. Парольный hash в ответы не выбирается. Клиенту отдаётся сырой opaque-токен (`secrets.token_urlsafe(32)`), в БД хранится только хеш.
|
||||
|
||||
Создание чата — одна транзакция: все `member_ids` должны существовать, иначе rollback и 400, затем вставка чата и участников. Занятый username — unique violation → 409 без текста SQL. `created_at` назначает процесс и делает его строго возрастающим, чтобы порядок `(created_at, id)` совпадал с порядком записи. Рестарт не меняет `expires_at`.
|
||||
|
||||
`GET /health/live` проверяет только процесс. `GET /health/ready` делает `SELECT 1`; без БД ответ 503 `unavailable`. Basic принимается только на `POST /api/v1/auth/sessions`. Остальные маршруты требуют Bearer. `X-User-Id` не идентифицирует пользователя. Пароли — Argon2id.
|
||||
|
||||
Переменные: `APP_HOST`, `APP_PORT`, `APP_ENV`, `LOG_LEVEL`, `SHUTDOWN_TIMEOUT_SECONDS`, `SESSION_TTL_SECONDS` читаются как в `.env.example`. `DATABASE_URL` задаёт compose; `DATABASE_URL_FILE` — необязательная замена. `SESSION_STORE=postgres` описывает это решение; кэш на оценке 3 не используется.
|
||||
|
||||
Из lab1 сохранены пользователи, чаты, членство, сообщения и keyset-пагинация. Идентификация lab1 (`X-User-Id`) заменена на пароль, Basic и Bearer.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --------------------------------- | ---------------- | --------------------- | ------------------- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | `python tests/smoke.py --base-url http://127.0.0.1:8080` на образе из Dockerfile | PASS: lab2 public API scenario | evidence/grade3.txt |
|
||||
| Данные и сессия переживают рестарт API и PostgreSQL | `tests/resilience.py --mode persistence --action-script scripts/restart.sh` | PASS. ID контейнеров не сменились (`15bfccf88c7a`, `cbe7139645a5`), volume `mtusi2026lab2-fork_pgdata` на месте | evidence/grade3.txt |
|
||||
| Повтор миграций не дублирует данные | второй `docker compose restart api`, затем counts | `schema_migrations` = 1, users = 14, messages = 6 и до, и после | evidence/grade3.txt |
|
||||
| Атомарное создание чата | `python scripts/check_grade3.py` | 400 на неизвестного участника, в `chats` строки с этим title нет | evidence/grade3.txt |
|
||||
| Expiry сессии | отдельный прогон с `SESSION_TTL_SECONDS=2`, затем возврат к 3600 | тот же токен через 3 с получил 401 | evidence/grade3.txt |
|
||||
| Недоступная БД | `docker compose stop postgres`, затем start | `/health/live` 200, `/health/ready` 503 `unavailable` без SQL | evidence/grade3.txt |
|
||||
| Секреты вне Git | `git check-ignore -v .env` | `.gitignore:2:.env` | — |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
`make check` эквивалентен `python scripts/check_contract.py` и тоже PASS. Контракт и публичные тесты не менялись.
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Отдельного нагрузочного эксперимента для оценки 3 нет.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| ----------- | ----------- | ------------- | ------------------------------------ |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| --- | --- | --- | --- |
|
||||
| `scripts/restart.sh` перезапускает api и postgres | Тот же Bearer читает прежнее сообщение, volume сохранён | PASS persistence; ID контейнеров те же, volume на месте | Готовность уложилась в бюджет теста (90 с). Подтверждённые строки не пропали |
|
||||
| Остановлен только postgres | live 200, ready 503, без SQL в теле | Так и было | После `start` ready снова 200. Данные volume не удалялись |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Один процесс API и одна БД. Потеря Docker-хоста уничтожает и API, и PostgreSQL. Сессии не в Redis: оценка 4 потребует Redis или Valkey, пул уже ограничен (`max_size` 10, таймаут 5 с), но гонка username, EXPLAIN на ≥10 000 сообщений и автоматические тесты короткого TTL не делались. Идемпотентность и вторая реплика — лабораторная 3 курса, не эта оценка.
|
||||
|
||||
Учебное упрощение: время сообщения монотонно только внутри одного процесса. На оценке 3 процесс один, поэтому порядок записи и `(created_at, id)` совпадают.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
import os
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
@@ -10,6 +11,24 @@ class Settings:
|
||||
log_level: str
|
||||
shutdown_timeout: int
|
||||
session_ttl_seconds: int
|
||||
database_url: str
|
||||
|
||||
|
||||
def _database_url() -> str:
|
||||
"""DATABASE_URL_FILE wins. The value is not logged."""
|
||||
file_name = os.getenv('DATABASE_URL_FILE', '').strip()
|
||||
if file_name:
|
||||
try:
|
||||
value = Path(file_name).read_text(encoding='utf-8').strip()
|
||||
except OSError:
|
||||
raise RuntimeError('DATABASE_URL_FILE could not be read') from None
|
||||
if not value:
|
||||
raise RuntimeError('DATABASE_URL_FILE is empty')
|
||||
return value
|
||||
value = os.getenv('DATABASE_URL', '').strip()
|
||||
if not value:
|
||||
raise RuntimeError('DATABASE_URL or DATABASE_URL_FILE is required')
|
||||
return value
|
||||
|
||||
|
||||
def load_settings() -> Settings:
|
||||
@@ -20,4 +39,5 @@ def load_settings() -> Settings:
|
||||
log_level=os.getenv('LOG_LEVEL', 'info').lower(),
|
||||
shutdown_timeout=int(os.getenv('SHUTDOWN_TIMEOUT_SECONDS', '5')),
|
||||
session_ttl_seconds=int(os.getenv('SESSION_TTL_SECONDS', '3600')),
|
||||
database_url=_database_url(),
|
||||
)
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
"""Connection pool. The URL is never written to the log."""
|
||||
import asyncio
|
||||
import logging
|
||||
|
||||
import asyncpg
|
||||
|
||||
logger = logging.getLogger('messenger')
|
||||
|
||||
_ATTEMPTS = 40
|
||||
|
||||
|
||||
async def open_pool(database_url: str) -> asyncpg.Pool:
|
||||
delay = 0.5
|
||||
last_type = 'error'
|
||||
for attempt in range(1, _ATTEMPTS + 1):
|
||||
pool = None
|
||||
try:
|
||||
pool = await asyncpg.create_pool(
|
||||
database_url,
|
||||
min_size=1,
|
||||
max_size=10,
|
||||
timeout=5,
|
||||
command_timeout=5,
|
||||
)
|
||||
async with pool.acquire() as conn:
|
||||
await conn.execute('SELECT 1')
|
||||
return pool
|
||||
except Exception as exc:
|
||||
last_type = type(exc).__name__
|
||||
if pool is not None:
|
||||
await pool.close()
|
||||
if attempt == _ATTEMPTS:
|
||||
break
|
||||
logger.warning('database is not ready (%s), retrying', last_type)
|
||||
await asyncio.sleep(delay)
|
||||
delay = min(delay * 1.5, 2)
|
||||
raise RuntimeError('database did not become reachable (%s)' % last_type)
|
||||
@@ -23,3 +23,7 @@ def not_found(message: str) -> ApiError:
|
||||
|
||||
def conflict(message: str) -> ApiError:
|
||||
return ApiError(409, 'conflict', message)
|
||||
|
||||
|
||||
def unavailable(message: str) -> ApiError:
|
||||
return ApiError(503, 'unavailable', message)
|
||||
|
||||
+16
-1
@@ -2,6 +2,7 @@ import json
|
||||
import logging
|
||||
import re
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
from pathlib import Path
|
||||
|
||||
from fastapi import FastAPI, Request
|
||||
@@ -10,7 +11,9 @@ from fastapi.responses import JSONResponse
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
|
||||
from .config import load_settings
|
||||
from .db import open_pool
|
||||
from .errors import ApiError
|
||||
from .migrate import apply_migrations
|
||||
from .routes import router
|
||||
from .store import Store
|
||||
|
||||
@@ -51,10 +54,23 @@ def _request_id(request: Request) -> str:
|
||||
_OPENAPI_PATH = Path(__file__).resolve().parents[1] / 'contracts' / 'openapi.json'
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app: FastAPI):
|
||||
settings = load_settings()
|
||||
pool = await open_pool(settings.database_url)
|
||||
try:
|
||||
await apply_migrations(pool)
|
||||
app.state.store = Store(pool, settings.session_ttl_seconds)
|
||||
yield
|
||||
finally:
|
||||
await pool.close()
|
||||
|
||||
|
||||
def create_app() -> FastAPI:
|
||||
app = FastAPI(
|
||||
title='MTUSI Messenger lab2',
|
||||
version='1.2.0',
|
||||
lifespan=lifespan,
|
||||
)
|
||||
|
||||
def openapi():
|
||||
@@ -63,7 +79,6 @@ def create_app() -> FastAPI:
|
||||
return app.openapi_schema
|
||||
|
||||
app.openapi = openapi
|
||||
app.state.store = Store(load_settings().session_ttl_seconds)
|
||||
|
||||
@app.middleware('http')
|
||||
async def request_context(request: Request, call_next):
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
"""Apply numbered SQL files once. Re-running records nothing new and inserts no rows."""
|
||||
import logging
|
||||
from pathlib import Path
|
||||
|
||||
import asyncpg
|
||||
|
||||
logger = logging.getLogger('messenger')
|
||||
|
||||
_MIGRATIONS = Path(__file__).resolve().parents[1] / 'migrations'
|
||||
|
||||
_BOOTSTRAP = """
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version TEXT PRIMARY KEY,
|
||||
applied_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
|
||||
)
|
||||
"""
|
||||
|
||||
|
||||
async def apply_migrations(pool: asyncpg.Pool) -> None:
|
||||
async with pool.acquire() as conn:
|
||||
await conn.execute(_BOOTSTRAP)
|
||||
rows = await conn.fetch('SELECT version FROM schema_migrations')
|
||||
applied = {row['version'] for row in rows}
|
||||
for path in sorted(_MIGRATIONS.glob('*.sql')):
|
||||
version = path.name
|
||||
if version in applied:
|
||||
logger.info('migration %s already applied', version)
|
||||
continue
|
||||
sql = path.read_text(encoding='utf-8')
|
||||
async with conn.transaction():
|
||||
await conn.execute(sql)
|
||||
await conn.execute(
|
||||
'INSERT INTO schema_migrations (version) VALUES ($1)',
|
||||
version,
|
||||
)
|
||||
logger.info('applied migration %s', version)
|
||||
+16
-16
@@ -26,7 +26,7 @@ async def current_user(request: Request) -> User:
|
||||
token = parse_bearer(request.headers.get('Authorization', ''))
|
||||
if token is None:
|
||||
raise unauthorized('Требуется действительная сессия', BEARER_CHALLENGE)
|
||||
user = request.app.state.store.user_for_token(token)
|
||||
user = await request.app.state.store.user_for_token(token)
|
||||
if user is None:
|
||||
raise unauthorized('Требуется действительная сессия', BEARER_CHALLENGE)
|
||||
return user
|
||||
@@ -45,12 +45,12 @@ async def read_body(request: Request, model: Type[Body]) -> Body:
|
||||
raise invalid_request('Тело запроса не соответствует контракту') from None
|
||||
|
||||
|
||||
def _member_chat(store: Store, chat_id: str, actor: User) -> Chat:
|
||||
async def _member_chat(store: Store, chat_id: str, actor: User) -> Chat:
|
||||
try:
|
||||
canonical = str(uuid.UUID(chat_id))
|
||||
except ValueError:
|
||||
raise invalid_request('Некорректный chat_id') from None
|
||||
chat = store.find_chat(canonical, actor.id)
|
||||
chat = await store.find_chat(canonical, actor.id)
|
||||
if chat is None:
|
||||
raise not_found('Чат не найден')
|
||||
return chat
|
||||
@@ -69,15 +69,15 @@ async def liveness() -> JSONResponse:
|
||||
|
||||
|
||||
@router.get('/health/ready')
|
||||
async def readiness() -> JSONResponse:
|
||||
"""In-memory only: the process itself is the single dependency of the sync path."""
|
||||
async def readiness(store: Store = Depends(get_store)) -> JSONResponse:
|
||||
await store.ready()
|
||||
return JSONResponse({'status': 'ok'})
|
||||
|
||||
|
||||
@router.post('/api/v1/users')
|
||||
async def register_user(request: Request, store: Store = Depends(get_store)) -> JSONResponse:
|
||||
payload = await read_body(request, CreateUser)
|
||||
user = store.create_user(payload.username, payload.display_name, payload.password)
|
||||
user = await store.create_user(payload.username, payload.display_name, payload.password)
|
||||
return JSONResponse(user.to_dict(), status_code=201)
|
||||
|
||||
|
||||
@@ -86,10 +86,10 @@ async def create_session(request: Request, store: Store = Depends(get_store)) ->
|
||||
parsed = parse_basic(request.headers.get('Authorization', ''))
|
||||
if parsed is None:
|
||||
raise unauthorized('Неверные учётные данные', BASIC_CHALLENGE)
|
||||
user = store.authenticate(*parsed)
|
||||
user = await store.authenticate(*parsed)
|
||||
if user is None:
|
||||
raise unauthorized('Неверные учётные данные', BASIC_CHALLENGE)
|
||||
token, expires_at = store.create_session(user.id)
|
||||
token, expires_at = await store.create_session(user.id)
|
||||
body = {
|
||||
'token': token,
|
||||
'token_type': 'Bearer',
|
||||
@@ -102,7 +102,7 @@ async def create_session(request: Request, store: Store = Depends(get_store)) ->
|
||||
@router.delete('/api/v1/auth/sessions/current')
|
||||
async def revoke_session(request: Request, actor: User = Depends(current_user)) -> Response:
|
||||
token = parse_bearer(request.headers.get('Authorization', ''))
|
||||
if token is None or not request.app.state.store.revoke_session(token):
|
||||
if token is None or not await request.app.state.store.revoke_session(token):
|
||||
raise unauthorized('Требуется действительная сессия', BEARER_CHALLENGE)
|
||||
return Response(status_code=204)
|
||||
|
||||
@@ -121,7 +121,7 @@ async def create_chat(
|
||||
payload = await read_body(request, CreateChat)
|
||||
if actor.id not in payload.member_ids:
|
||||
raise invalid_request('Создатель чата должен быть указан в member_ids')
|
||||
chat = store.create_chat(payload.title, payload.member_ids)
|
||||
chat = await store.create_chat(payload.title, payload.member_ids)
|
||||
return JSONResponse(chat.to_dict(), status_code=201)
|
||||
|
||||
|
||||
@@ -133,7 +133,7 @@ async def list_chats(
|
||||
) -> JSONResponse:
|
||||
scope = 'chats:' + actor.id
|
||||
limit, after = parse_page(request.query_params, scope)
|
||||
chats, has_more = store.list_chats(actor.id, limit, after)
|
||||
chats, has_more = await store.list_chats(actor.id, limit, after)
|
||||
return JSONResponse(_page(chats, has_more, scope))
|
||||
|
||||
|
||||
@@ -143,7 +143,7 @@ async def show_chat(
|
||||
actor: User = Depends(current_user),
|
||||
store: Store = Depends(get_store),
|
||||
) -> JSONResponse:
|
||||
return JSONResponse(_member_chat(store, chat_id, actor).to_dict())
|
||||
return JSONResponse((await _member_chat(store, chat_id, actor)).to_dict())
|
||||
|
||||
|
||||
@router.post('/api/v1/chats/{chat_id}/messages')
|
||||
@@ -153,9 +153,9 @@ async def send_message(
|
||||
actor: User = Depends(current_user),
|
||||
store: Store = Depends(get_store),
|
||||
) -> JSONResponse:
|
||||
chat = _member_chat(store, chat_id, actor)
|
||||
chat = await _member_chat(store, chat_id, actor)
|
||||
payload = await read_body(request, CreateMessage)
|
||||
message = store.add_message(chat.id, actor.id, payload.text)
|
||||
message = await store.add_message(chat.id, actor.id, payload.text)
|
||||
return JSONResponse(message.to_dict(), status_code=201)
|
||||
|
||||
|
||||
@@ -166,8 +166,8 @@ async def list_messages(
|
||||
actor: User = Depends(current_user),
|
||||
store: Store = Depends(get_store),
|
||||
) -> JSONResponse:
|
||||
chat = _member_chat(store, chat_id, actor)
|
||||
chat = await _member_chat(store, chat_id, actor)
|
||||
scope = 'messages:' + chat.id
|
||||
limit, after = parse_page(request.query_params, scope)
|
||||
messages, has_more = store.list_messages(chat.id, limit, after)
|
||||
messages, has_more = await store.list_messages(chat.id, limit, after)
|
||||
return JSONResponse(_page(messages, has_more, scope))
|
||||
|
||||
+271
-92
@@ -2,12 +2,13 @@ import hashlib
|
||||
import secrets
|
||||
import threading
|
||||
import uuid
|
||||
from bisect import bisect_right
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import Dict, List, Optional, Sequence, Tuple
|
||||
|
||||
from .errors import conflict, invalid_request
|
||||
import asyncpg
|
||||
|
||||
from .errors import conflict, invalid_request, unavailable
|
||||
from .pagination import Key
|
||||
from .passwords import hash_password, password_matches
|
||||
|
||||
@@ -62,23 +63,6 @@ class Message:
|
||||
}
|
||||
|
||||
|
||||
class _Timeline:
|
||||
"""Append-only sequence ordered by (created_at, id), paginated with bisect."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._keys: List[Key] = []
|
||||
self._items: List = []
|
||||
|
||||
def append(self, item) -> None:
|
||||
self._keys.append((item.created_at, item.id))
|
||||
self._items.append(item)
|
||||
|
||||
def page(self, limit: int, after: Optional[Key]) -> Tuple[List, bool]:
|
||||
start = bisect_right(self._keys, after) if after is not None else 0
|
||||
items = self._items[start:start + limit]
|
||||
return items, start + len(items) < len(self._items)
|
||||
|
||||
|
||||
def _token_key(token: str) -> str:
|
||||
return hashlib.sha256(token.encode('utf-8')).hexdigest()
|
||||
|
||||
@@ -87,102 +71,297 @@ def _stamp(moment: datetime) -> str:
|
||||
return moment.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z')
|
||||
|
||||
|
||||
class Store:
|
||||
"""Single owner of mutable state; one lock keeps concurrent requests consistent."""
|
||||
def _parse_stamp(value: str) -> datetime:
|
||||
if value.endswith('Z'):
|
||||
value = value[:-1] + '+00:00'
|
||||
return datetime.fromisoformat(value)
|
||||
|
||||
def __init__(self, session_ttl_seconds: int = 3600) -> None:
|
||||
|
||||
def _user(row: asyncpg.Record) -> User:
|
||||
return User(str(row['id']), row['username'], row['display_name'], _stamp(row['created_at']))
|
||||
|
||||
|
||||
def _as_uuid(value: str, message: str) -> uuid.UUID:
|
||||
try:
|
||||
return uuid.UUID(value)
|
||||
except ValueError:
|
||||
raise invalid_request(message) from None
|
||||
|
||||
|
||||
class Store:
|
||||
"""PostgreSQL is the source of truth. One process clock keeps created_at ordered."""
|
||||
|
||||
def __init__(self, pool: asyncpg.Pool, session_ttl_seconds: int = 3600) -> None:
|
||||
self._pool = pool
|
||||
self._session_ttl = timedelta(seconds=session_ttl_seconds)
|
||||
self._lock = threading.Lock()
|
||||
self._users: Dict[str, User] = {}
|
||||
self._user_id_by_username: Dict[str, str] = {}
|
||||
self._password_hashes: Dict[str, str] = {}
|
||||
self._sessions: Dict[str, Tuple[str, datetime]] = {}
|
||||
self._chats: Dict[str, Chat] = {}
|
||||
self._chats_of_user: Dict[str, _Timeline] = {}
|
||||
self._messages_of_chat: Dict[str, _Timeline] = {}
|
||||
self._last_moment: Optional[datetime] = None
|
||||
|
||||
def _now(self) -> str:
|
||||
def _now(self) -> datetime:
|
||||
"""Strictly increasing server time, so append order always equals sort order."""
|
||||
moment = datetime.now(timezone.utc)
|
||||
if self._last_moment is not None and moment <= self._last_moment:
|
||||
moment = self._last_moment + timedelta(microseconds=1)
|
||||
self._last_moment = moment
|
||||
return _stamp(moment)
|
||||
with self._lock:
|
||||
moment = datetime.now(timezone.utc)
|
||||
if self._last_moment is not None and moment <= self._last_moment:
|
||||
moment = self._last_moment + timedelta(microseconds=1)
|
||||
self._last_moment = moment
|
||||
return moment
|
||||
|
||||
def create_user(self, username: str, display_name: str, password: str) -> User:
|
||||
async def ready(self) -> None:
|
||||
try:
|
||||
async with self._pool.acquire() as conn:
|
||||
await conn.execute('SELECT 1')
|
||||
except Exception:
|
||||
raise unavailable('Хранилище недоступно') from None
|
||||
|
||||
async def create_user(self, username: str, display_name: str, password: str) -> User:
|
||||
password_hash = hash_password(password)
|
||||
with self._lock:
|
||||
if username in self._user_id_by_username:
|
||||
raise conflict('Username уже занят')
|
||||
user = User(str(uuid.uuid4()), username, display_name, self._now())
|
||||
self._users[user.id] = user
|
||||
self._user_id_by_username[username] = user.id
|
||||
self._password_hashes[user.id] = password_hash
|
||||
return user
|
||||
user_id = uuid.uuid4()
|
||||
created = self._now()
|
||||
try:
|
||||
async with self._pool.acquire() as conn:
|
||||
await conn.execute(
|
||||
'''
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
''',
|
||||
user_id,
|
||||
username,
|
||||
display_name,
|
||||
password_hash,
|
||||
created,
|
||||
)
|
||||
except asyncpg.UniqueViolationError:
|
||||
raise conflict('Username уже занят') from None
|
||||
return User(str(user_id), username, display_name, _stamp(created))
|
||||
|
||||
def authenticate(self, username: str, password: str) -> Optional[User]:
|
||||
with self._lock:
|
||||
user_id = self._user_id_by_username.get(username)
|
||||
user = self._users.get(user_id) if user_id is not None else None
|
||||
stored_hash = self._password_hashes.get(user_id) if user_id is not None else None
|
||||
if not password_matches(stored_hash, password):
|
||||
async def authenticate(self, username: str, password: str) -> Optional[User]:
|
||||
async with self._pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
'''
|
||||
SELECT id, username, display_name, created_at, password_hash
|
||||
FROM users
|
||||
WHERE username = $1
|
||||
''',
|
||||
username,
|
||||
)
|
||||
stored_hash = row['password_hash'] if row is not None else None
|
||||
if not password_matches(stored_hash, password) or row is None:
|
||||
return None
|
||||
return user
|
||||
return _user(row)
|
||||
|
||||
def create_session(self, user_id: str) -> Tuple[str, str]:
|
||||
async def create_session(self, user_id: str) -> Tuple[str, str]:
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires = datetime.now(timezone.utc) + self._session_ttl
|
||||
with self._lock:
|
||||
self._sessions[_token_key(token)] = (user_id, expires)
|
||||
async with self._pool.acquire() as conn:
|
||||
await conn.execute(
|
||||
'''
|
||||
INSERT INTO sessions (token_hash, user_id, expires_at)
|
||||
VALUES ($1, $2, $3)
|
||||
''',
|
||||
_token_key(token),
|
||||
_as_uuid(user_id, 'Некорректный user_id'),
|
||||
expires,
|
||||
)
|
||||
return token, _stamp(expires)
|
||||
|
||||
def user_for_token(self, token: str) -> Optional[User]:
|
||||
async def user_for_token(self, token: str) -> Optional[User]:
|
||||
now = datetime.now(timezone.utc)
|
||||
with self._lock:
|
||||
record = self._sessions.get(_token_key(token))
|
||||
if record is None:
|
||||
key = _token_key(token)
|
||||
async with self._pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
'''
|
||||
SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
|
||||
FROM sessions s
|
||||
JOIN users u ON u.id = s.user_id
|
||||
WHERE s.token_hash = $1
|
||||
''',
|
||||
key,
|
||||
)
|
||||
if row is None:
|
||||
return None
|
||||
user_id, expires = record
|
||||
if expires <= now:
|
||||
del self._sessions[_token_key(token)]
|
||||
if row['expires_at'] <= now:
|
||||
await conn.execute('DELETE FROM sessions WHERE token_hash = $1', key)
|
||||
return None
|
||||
return self._users.get(user_id)
|
||||
return _user(row)
|
||||
|
||||
def revoke_session(self, token: str) -> bool:
|
||||
async def revoke_session(self, token: str) -> bool:
|
||||
now = datetime.now(timezone.utc)
|
||||
with self._lock:
|
||||
record = self._sessions.pop(_token_key(token), None)
|
||||
return record is not None and record[1] > now
|
||||
async with self._pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
'''
|
||||
DELETE FROM sessions
|
||||
WHERE token_hash = $1 AND expires_at > $2
|
||||
RETURNING token_hash
|
||||
''',
|
||||
_token_key(token),
|
||||
now,
|
||||
)
|
||||
return row is not None
|
||||
|
||||
def create_chat(self, title: str, member_ids: Sequence[str]) -> Chat:
|
||||
with self._lock:
|
||||
if any(member_id not in self._users for member_id in member_ids):
|
||||
raise invalid_request('Все участники должны быть существующими пользователями')
|
||||
chat = Chat(str(uuid.uuid4()), title, tuple(member_ids), self._now())
|
||||
self._chats[chat.id] = chat
|
||||
for member_id in member_ids:
|
||||
self._chats_of_user.setdefault(member_id, _Timeline()).append(chat)
|
||||
return chat
|
||||
async def create_chat(self, title: str, member_ids: Sequence[str]) -> Chat:
|
||||
ids = [_as_uuid(member_id, 'Некорректный user_id') for member_id in member_ids]
|
||||
chat_id = uuid.uuid4()
|
||||
created = self._now()
|
||||
async with self._pool.acquire() as conn:
|
||||
async with conn.transaction():
|
||||
found = await conn.fetch(
|
||||
'SELECT id FROM users WHERE id = ANY($1::uuid[])',
|
||||
ids,
|
||||
)
|
||||
if len(found) != len(ids):
|
||||
raise invalid_request('Все участники должны быть существующими пользователями')
|
||||
await conn.execute(
|
||||
'INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)',
|
||||
chat_id,
|
||||
title,
|
||||
created,
|
||||
)
|
||||
await conn.execute(
|
||||
'''
|
||||
INSERT INTO chat_members (chat_id, user_id, position)
|
||||
SELECT $1, member_id, (ordinality - 1)::integer
|
||||
FROM unnest($2::uuid[]) WITH ORDINALITY AS members(member_id, ordinality)
|
||||
''',
|
||||
chat_id,
|
||||
ids,
|
||||
)
|
||||
return Chat(str(chat_id), title, tuple(member_ids), _stamp(created))
|
||||
|
||||
def find_chat(self, chat_id: str, member_id: str) -> Optional[Chat]:
|
||||
async def find_chat(self, chat_id: str, member_id: str) -> Optional[Chat]:
|
||||
"""A chat of somebody else is indistinguishable from a missing one."""
|
||||
with self._lock:
|
||||
chat = self._chats.get(chat_id)
|
||||
return chat if chat is not None and member_id in chat.member_ids else None
|
||||
chat_uuid = _as_uuid(chat_id, 'Некорректный chat_id')
|
||||
member_uuid = _as_uuid(member_id, 'Некорректный user_id')
|
||||
async with self._pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
'''
|
||||
SELECT c.id, c.title, c.created_at
|
||||
FROM chats c
|
||||
JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = $2
|
||||
WHERE c.id = $1
|
||||
''',
|
||||
chat_uuid,
|
||||
member_uuid,
|
||||
)
|
||||
if row is None:
|
||||
return None
|
||||
members = await self._members(conn, [chat_uuid])
|
||||
return Chat(str(row['id']), row['title'], members.get(chat_uuid, ()), _stamp(row['created_at']))
|
||||
|
||||
def list_chats(self, member_id: str, limit: int, after: Optional[Key]) -> Tuple[List[Chat], bool]:
|
||||
with self._lock:
|
||||
timeline = self._chats_of_user.get(member_id)
|
||||
return timeline.page(limit, after) if timeline is not None else ([], False)
|
||||
async def list_chats(self, member_id: str, limit: int, after: Optional[Key]) -> Tuple[List[Chat], bool]:
|
||||
member_uuid = _as_uuid(member_id, 'Некорректный user_id')
|
||||
after_at, after_id = self._cursor(after)
|
||||
async with self._pool.acquire() as conn:
|
||||
if after_at is None:
|
||||
rows = await conn.fetch(
|
||||
'''
|
||||
SELECT c.id, c.title, c.created_at
|
||||
FROM chats c
|
||||
JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = $1
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT $2
|
||||
''',
|
||||
member_uuid,
|
||||
limit + 1,
|
||||
)
|
||||
else:
|
||||
rows = await conn.fetch(
|
||||
'''
|
||||
SELECT c.id, c.title, c.created_at
|
||||
FROM chats c
|
||||
JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = $1
|
||||
WHERE (c.created_at, c.id) > ($2::timestamptz, $3::uuid)
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT $4
|
||||
''',
|
||||
member_uuid,
|
||||
after_at,
|
||||
after_id,
|
||||
limit + 1,
|
||||
)
|
||||
page = rows[:limit]
|
||||
members = await self._members(conn, [row['id'] for row in page])
|
||||
chats = [
|
||||
Chat(str(row['id']), row['title'], members.get(row['id'], ()), _stamp(row['created_at']))
|
||||
for row in page
|
||||
]
|
||||
return chats, len(rows) > limit
|
||||
|
||||
def add_message(self, chat_id: str, sender_id: str, text: str) -> Message:
|
||||
with self._lock:
|
||||
message = Message(str(uuid.uuid4()), chat_id, sender_id, text, self._now())
|
||||
self._messages_of_chat.setdefault(chat_id, _Timeline()).append(message)
|
||||
return message
|
||||
async def add_message(self, chat_id: str, sender_id: str, text: str) -> Message:
|
||||
message_id = uuid.uuid4()
|
||||
created = self._now()
|
||||
async with self._pool.acquire() as conn:
|
||||
await conn.execute(
|
||||
'''
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
''',
|
||||
message_id,
|
||||
_as_uuid(chat_id, 'Некорректный chat_id'),
|
||||
_as_uuid(sender_id, 'Некорректный user_id'),
|
||||
text,
|
||||
created,
|
||||
)
|
||||
return Message(str(message_id), chat_id, sender_id, text, _stamp(created))
|
||||
|
||||
def list_messages(self, chat_id: str, limit: int, after: Optional[Key]) -> Tuple[List[Message], bool]:
|
||||
with self._lock:
|
||||
timeline = self._messages_of_chat.get(chat_id)
|
||||
return timeline.page(limit, after) if timeline is not None else ([], False)
|
||||
async def list_messages(self, chat_id: str, limit: int, after: Optional[Key]) -> Tuple[List[Message], bool]:
|
||||
chat_uuid = _as_uuid(chat_id, 'Некорректный chat_id')
|
||||
after_at, after_id = self._cursor(after)
|
||||
async with self._pool.acquire() as conn:
|
||||
if after_at is None:
|
||||
rows = await conn.fetch(
|
||||
'''
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at, id
|
||||
LIMIT $2
|
||||
''',
|
||||
chat_uuid,
|
||||
limit + 1,
|
||||
)
|
||||
else:
|
||||
rows = await conn.fetch(
|
||||
'''
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
AND (created_at, id) > ($2::timestamptz, $3::uuid)
|
||||
ORDER BY created_at, id
|
||||
LIMIT $4
|
||||
''',
|
||||
chat_uuid,
|
||||
after_at,
|
||||
after_id,
|
||||
limit + 1,
|
||||
)
|
||||
page = rows[:limit]
|
||||
messages = [
|
||||
Message(str(row['id']), str(row['chat_id']), str(row['sender_id']), row['text'], _stamp(row['created_at']))
|
||||
for row in page
|
||||
]
|
||||
return messages, len(rows) > limit
|
||||
|
||||
async def _members(self, conn: asyncpg.Connection, chat_ids: Sequence[uuid.UUID]) -> Dict[uuid.UUID, Tuple[str, ...]]:
|
||||
if not chat_ids:
|
||||
return {}
|
||||
rows = await conn.fetch(
|
||||
'''
|
||||
SELECT chat_id, user_id
|
||||
FROM chat_members
|
||||
WHERE chat_id = ANY($1::uuid[])
|
||||
ORDER BY chat_id, position
|
||||
''',
|
||||
list(chat_ids),
|
||||
)
|
||||
grouped: Dict[uuid.UUID, List[str]] = {}
|
||||
for row in rows:
|
||||
grouped.setdefault(row['chat_id'], []).append(str(row['user_id']))
|
||||
return {chat_id: tuple(member_ids) for chat_id, member_ids in grouped.items()}
|
||||
|
||||
def _cursor(self, after: Optional[Key]) -> Tuple[Optional[datetime], Optional[uuid.UUID]]:
|
||||
if after is None:
|
||||
return None, None
|
||||
try:
|
||||
return _parse_stamp(after[0]), uuid.UUID(after[1])
|
||||
except ValueError:
|
||||
raise invalid_request('Некорректный cursor') from None
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
# Local lab2 grade-3 stand. Secrets come from .env, which is not committed.
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.10-alpine
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
|
||||
POSTGRES_DB: ${POSTGRES_DB}
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
|
||||
interval: 2s
|
||||
timeout: 5s
|
||||
retries: 30
|
||||
ports:
|
||||
- "127.0.0.1:5432:5432"
|
||||
restart: unless-stopped
|
||||
|
||||
api:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
environment:
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: "8080"
|
||||
APP_ENV: ${APP_ENV:-lab}
|
||||
LOG_LEVEL: ${LOG_LEVEL:-info}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
SHUTDOWN_TIMEOUT_SECONDS: ${SHUTDOWN_TIMEOUT_SECONDS:-5}
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
|
||||
ports:
|
||||
- "127.0.0.1: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=3)
|
||||
interval: 3s
|
||||
timeout: 5s
|
||||
retries: 30
|
||||
start_period: 20s
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
@@ -0,0 +1,39 @@
|
||||
Grade 3 checks. No tokens, passwords, or connection strings.
|
||||
|
||||
make check equivalent:
|
||||
.venv/Scripts/python.exe scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
|
||||
Pinned image smoke, http://127.0.0.1:8080:
|
||||
.venv/Scripts/python.exe tests/smoke.py --base-url http://127.0.0.1:8080
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
|
||||
Persistence on the same image. The public harness executes scripts/restart.sh.
|
||||
On this Windows host CreateProcess cannot run a shell script (WinError 193), and the
|
||||
only WSL distro is docker-desktop. The harness was therefore run inside docker:28-cli
|
||||
with python3, the compose network, and the Docker socket. The hook was still
|
||||
scripts/restart.sh. BASE_URL was http://api:8080.
|
||||
PASS: persistence preserved confirmed data and existing session.
|
||||
|
||||
Containers before and after that hook kept the same IDs (restart, not recreate):
|
||||
api 15bfccf88c7a
|
||||
postgres cbe7139645a5
|
||||
Volume still present: mtusi2026lab2-fork_pgdata
|
||||
|
||||
Second API start, same volume, migrations not re-inserted:
|
||||
before: migrations=1 users=14 messages=6
|
||||
after: migrations=1 users=14 messages=6
|
||||
|
||||
Unknown member:
|
||||
.venv/Scripts/python.exe scripts/check_grade3.py
|
||||
PASS: unknown member returns 400 and leaves no chat row
|
||||
|
||||
Short TTL, separate from persistence. API recreated with SESSION_TTL_SECONDS=2,
|
||||
then .env restored to 3600 and the API recreated again.
|
||||
PASS: same token got 401 after 3 seconds.
|
||||
|
||||
Postgres stopped, API left running:
|
||||
GET /health/live 200 {"status":"ok"}
|
||||
GET /health/ready 503 {"error":{"code":"unavailable","message":"Хранилище недоступно",...}}
|
||||
request_id in the body matched X-Request-Id. Body had no SQL.
|
||||
Postgres was started again; /health/ready returned 200.
|
||||
@@ -0,0 +1,53 @@
|
||||
-- Initial schema. The runner records this file in schema_migrations and skips it on the next start.
|
||||
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version TEXT PRIMARY KEY,
|
||||
applied_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
|
||||
CREATE TABLE users (
|
||||
id UUID PRIMARY KEY,
|
||||
username TEXT NOT NULL,
|
||||
display_name TEXT NOT NULL,
|
||||
password_hash TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL,
|
||||
CONSTRAINT users_username_unique UNIQUE (username),
|
||||
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
|
||||
);
|
||||
|
||||
CREATE TABLE sessions (
|
||||
token_hash TEXT PRIMARY KEY,
|
||||
user_id UUID NOT NULL REFERENCES users (id),
|
||||
expires_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id UUID PRIMARY KEY,
|
||||
title TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL,
|
||||
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id UUID NOT NULL REFERENCES chats (id),
|
||||
user_id UUID NOT NULL REFERENCES users (id),
|
||||
position INTEGER NOT NULL,
|
||||
PRIMARY KEY (chat_id, user_id),
|
||||
CONSTRAINT chat_members_position_nonnegative CHECK (position >= 0)
|
||||
);
|
||||
|
||||
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,
|
||||
created_at TIMESTAMPTZ NOT NULL,
|
||||
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000)
|
||||
);
|
||||
|
||||
-- Keyset history: WHERE chat_id = ? AND (created_at, id) > cursor ORDER BY created_at, id.
|
||||
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
|
||||
|
||||
-- Chat list is filtered by the caller, then ordered by the chat's own (created_at, id).
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id);
|
||||
@@ -1,4 +1,5 @@
|
||||
# Direct: fastapi, pydantic, uvicorn, argon2-cffi. The rest are their dependencies, pinned.
|
||||
asyncpg==0.32.0
|
||||
annotated-doc==0.0.5
|
||||
annotated-types==0.8.0
|
||||
anyio==4.15.1
|
||||
|
||||
@@ -0,0 +1,92 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Grade-3 check that is not part of make test.
|
||||
|
||||
Creates a chat with one unknown member and expects 400. Then asks PostgreSQL
|
||||
whether that title was stored. A rollback leaves zero rows.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
|
||||
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
BASE_URL = os.environ.get('BASE_URL', 'http://127.0.0.1:8080').rstrip('/')
|
||||
|
||||
|
||||
def request(method, path, body=None, headers=None, expected=200):
|
||||
data = None if body is None else json.dumps(body).encode('utf-8')
|
||||
req = urllib.request.Request(BASE_URL + path, data=data, method=method)
|
||||
req.add_header('Content-Type', 'application/json')
|
||||
for key, value in (headers or {}).items():
|
||||
req.add_header(key, value)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=10) as response:
|
||||
status = response.status
|
||||
payload = response.read()
|
||||
except urllib.error.HTTPError as exc:
|
||||
status = exc.code
|
||||
payload = exc.read()
|
||||
if status != expected:
|
||||
sys.stderr.write('expected %s %s -> %s, got %s %s\n' % (method, path, expected, status, payload[:300]))
|
||||
return None
|
||||
if not payload:
|
||||
return {}
|
||||
return json.loads(payload)
|
||||
|
||||
|
||||
def main():
|
||||
username = 'u_orphan_' + uuid.uuid4().hex[:12]
|
||||
password = 'T3st-' + uuid.uuid4().hex
|
||||
user = request('POST', '/api/v1/users', {
|
||||
'username': username,
|
||||
'display_name': 'Orphan check',
|
||||
'password': password,
|
||||
}, expected=201)
|
||||
if user is None:
|
||||
return 1
|
||||
import base64
|
||||
basic = base64.b64encode((username + ':' + password).encode('utf-8')).decode('ascii')
|
||||
session = request('POST', '/api/v1/auth/sessions', headers={'Authorization': 'Basic ' + basic}, expected=201)
|
||||
if session is None:
|
||||
return 1
|
||||
title = 'orphan-' + uuid.uuid4().hex
|
||||
missing = str(uuid.uuid4())
|
||||
rejected = request(
|
||||
'POST',
|
||||
'/api/v1/chats',
|
||||
{'title': title, 'member_ids': [user['id'], missing]},
|
||||
headers={'Authorization': 'Bearer ' + session['token']},
|
||||
expected=400,
|
||||
)
|
||||
if rejected is None:
|
||||
return 1
|
||||
sql = "SELECT count(*) FROM chats WHERE title = '%s'" % title.replace("'", '')
|
||||
probe = subprocess.run(
|
||||
[
|
||||
'docker', 'compose', '--env-file', '.env', 'exec', '-T', 'postgres',
|
||||
'psql', '-U', os.environ.get('POSTGRES_USER', 'messenger'),
|
||||
'-d', os.environ.get('POSTGRES_DB', 'messenger'),
|
||||
'-tAc', sql,
|
||||
],
|
||||
cwd=ROOT,
|
||||
check=False,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
)
|
||||
if probe.returncode != 0:
|
||||
sys.stderr.write(probe.stderr)
|
||||
return 1
|
||||
count = probe.stdout.strip()
|
||||
if count != '0':
|
||||
sys.stderr.write('rolled-back chat is still stored: count=%s\n' % count)
|
||||
return 1
|
||||
print('PASS: unknown member returns 400 and leaves no chat row')
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
# Restart the API and PostgreSQL. Named volumes stay; nothing is re-seeded.
|
||||
docker compose --env-file .env restart api postgres
|
||||
Reference in New Issue
Block a user