level 3 basics

This commit is contained in:
2026-10-26 16:42:32 +03:00
parent 3bd25a9127
commit 9d3de3b2d9
16 changed files with 703 additions and 126 deletions
+9 -2
View File
@@ -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
+1
View File
@@ -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
+53 -15
View File
@@ -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)` совпадают.
+20
View File
@@ -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(),
)
+37
View File
@@ -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)
+4
View File
@@ -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
View File
@@ -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):
+36
View File
@@ -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
View File
@@ -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
View File
@@ -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
+50
View File
@@ -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:
+39
View File
@@ -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.
+53
View File
@@ -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
View File
@@ -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
+92
View File
@@ -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())
+5
View File
@@ -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