Lab2: PostgreSQL, Bearer sessions and Redis for grade 4
This commit is contained in:
+9
-4
@@ -1,11 +1,16 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
SESSION_STORE=redis
|
||||
# Compose mounts these secret files into the API container:
|
||||
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
|
||||
# Optional direct URLs for host-side tools (scripts/explain_messages.py):
|
||||
# DATABASE_URL=postgresql://messenger:PASSWORD@127.0.0.1:5432/messenger
|
||||
# CACHE_URL=redis://127.0.0.1:6379/0
|
||||
DB_CONNECT_TIMEOUT=5
|
||||
DB_POOL_MIN=1
|
||||
DB_POOL_MAX=10
|
||||
REDIS_SOCKET_TIMEOUT=3
|
||||
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
# Закреплённый runtime-образ (Python интерпретируемый — один stage).
|
||||
FROM python:3.12.7-slim-bookworm
|
||||
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
RUN groupadd --system app && useradd --system --gid app --home /app --shell /usr/sbin/nologin app
|
||||
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
COPY app ./app
|
||||
COPY migrations ./migrations
|
||||
|
||||
USER app
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=5 \
|
||||
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"
|
||||
|
||||
# PID 1 = uvicorn; SIGTERM обрабатывается lifespan'ом приложения.
|
||||
CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -4,10 +4,10 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence
|
||||
.PHONY: help check validate test test-own load test-persistence secrets up down
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "check: offline structure; validate: OpenAPI; test: smoke; test-own: student; test-persistence: restart hook"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -18,9 +18,21 @@ validate:
|
||||
test:
|
||||
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
test-own:
|
||||
$(PYTHON) tests/own.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
load:
|
||||
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
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)
|
||||
|
||||
secrets:
|
||||
@echo "Run: powershell -File scripts/make_secrets.ps1 OR sh scripts/make_secrets.sh"
|
||||
|
||||
up:
|
||||
docker compose --env-file .env up -d --build
|
||||
|
||||
down:
|
||||
docker compose --env-file .env down
|
||||
|
||||
@@ -1,37 +1,112 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Автор, группа: Соболев Даниил Романович, БПИ2302
|
||||
- Целевая оценка; выбранный трек 5, если нужен: 4
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Использованные источники, библиотеки и помощь ИИ: FastAPI, Uvicorn, Pydantic, psycopg3+pool, redis-py, argon2-cffi; контракт курса; помощь ИИ при переносе на PostgreSQL/сессии/Redis
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
**Prerequisites:** Docker / Docker Compose; Python 3.9+ для `make test` / `make test-own` (stdlib).
|
||||
|
||||
```sh
|
||||
cp .env.example .env
|
||||
# Windows:
|
||||
powershell -File scripts/make_secrets.ps1
|
||||
# Unix:
|
||||
# sh scripts/make_secrets.sh
|
||||
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build
|
||||
```
|
||||
|
||||
Ожидание готовности: `GET http://localhost:8080/health/ready` → `{"status":"ok"}` (миграции применяются при старте API).
|
||||
|
||||
```sh
|
||||
make test
|
||||
# Windows: py -3 tests\smoke.py --base-url http://localhost:8080
|
||||
make test-own
|
||||
# Unix / Git Bash:
|
||||
# chmod +x scripts/restart.sh && make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
# Windows (cmd):
|
||||
py -3 tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:8080
|
||||
```
|
||||
|
||||
Проверка expiry (отдельный прогон с коротким TTL):
|
||||
|
||||
```sh
|
||||
# SESSION_TTL_SECONDS=5 в env-файле, затем recreate api и:
|
||||
# SESSION_TTL_SECONDS=5 py -3 tests\own.py
|
||||
# или: py -3 scripts\test_expiry_raw.py
|
||||
```
|
||||
|
||||
EXPLAIN индекса истории (≥10 000 сообщений):
|
||||
|
||||
```sh
|
||||
# из secrets/database_url заменить хост postgres → 127.0.0.1
|
||||
set DATABASE_URL=postgresql://messenger:PASSWORD@127.0.0.1:15432/messenger
|
||||
set CACHE_URL=redis://127.0.0.1:6379/0
|
||||
py -3 scripts/explain_messages.py
|
||||
# результат: evidence/explain.txt
|
||||
```
|
||||
|
||||
Безопасная остановка (volumes сохраняются):
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env stop
|
||||
# или down без -v
|
||||
docker compose --env-file .env down
|
||||
```
|
||||
|
||||
Намеренное удаление учебных данных:
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env down -v
|
||||
```
|
||||
|
||||
Версии: `python:3.12.7-slim-bookworm`, `postgres:16.4-bookworm`, `redis:7.4.1-bookworm`; зависимости в `requirements.txt`.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
Клиент → API (FastAPI) → PostgreSQL (источник истины: users/chats/members/messages)
|
||||
→ Redis (opaque Bearer-сессии, TTL + AOF everysec)
|
||||
```
|
||||
|
||||
- **Перенос из lab1:** контракт users/chats/messages, keyset-cursor, формат ошибок, non-root Dockerfile, X-Request-Id.
|
||||
- **Изменения lab2:** `password` + Argon2id; `POST /auth/sessions` (Basic); Bearer вместо `X-User-Id`; сессии в Redis.
|
||||
- **Источник истины данных:** PostgreSQL. Сессии — Redis (единственное хранилище сессий) с AOF, чтобы переживать `compose restart`.
|
||||
- **Транзакции:** создание чата = `INSERT chats` + `INSERT chat_members` в одной транзакции; при неизвестном участнике — rollback.
|
||||
- **Пул/таймауты:** `psycopg_pool.ConnectionPool` (min/max), `connect_timeout`; Redis `socket_connect_timeout` / `socket_timeout`.
|
||||
- **Индекс истории:** `messages (chat_id, created_at, id)` под keyset `WHERE chat_id=$1 AND (created_at,id)>($2,$3) ORDER BY created_at,id LIMIT n`.
|
||||
- **Ready:** live = процесс; ready = accepting + ping Postgres + ping Redis.
|
||||
- **Конфиг:** `.env` + secret-файлы `DATABASE_URL_FILE` / `CACHE_URL_FILE` (см. `.env.example`).
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke | `make test` | PASS: lab2 public API scenario | `evidence/smoke.txt` |
|
||||
| Persistence + сессия | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS: token и сообщение после restart | `evidence/persistence.txt` |
|
||||
| Собственные тесты 4 | `make test-own` | wrong password, logout, race username, concurrency, redis-down | `evidence/own.txt` |
|
||||
| Expiry короткого TTL | `SESSION_TTL_SECONDS=2` + `make test-own` | 401 после TTL | `evidence/own.txt` |
|
||||
| EXPLAIN ≥10k | `scripts/explain_messages.py` | Index Scan по `messages_chat_created_id_idx` | `evidence/explain.txt` |
|
||||
| Миграции идемпотентны | повторный `up` / restart API | без дублей schema_migrations | логи API |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| `scripts/restart.sh` (API+Postgres+Redis, volumes) | те же данные и Bearer | persistence PASS | до готовности ≤90 с; без потери при сохранённых volumes |
|
||||
| `docker compose stop redis` | ready 503; нет анонимного доступа | own redis-down PASS | после `start redis` ready снова ok |
|
||||
| Гонка 8× одинаковый username | 1×201 + 7×409 | own username race PASS | без дублей username |
|
||||
| 10×10 POST сообщений | 100 уникальных | own concurrency PASS | без потери подтверждённых |
|
||||
|
||||
Ограничения измерения: closed-loop smoke/own на localhost; `tests/load.py` — throughput HTTP-подтверждений, не точный счётчик COMMIT.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- Один Docker-host: нет HA Postgres/Redis/API.
|
||||
- Сессии только в Redis: flush/AOF-сбой без Postgres-backup сессий = повторный login (данные чатов в PG сохраняются).
|
||||
- Нет lab3 LB/идемпотентности, вложений, TLS.
|
||||
- Следующий шаг курса: горизонтальное масштабирование и общий session store.
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
"""Messenger API lab2: PostgreSQL + Bearer sessions + Redis."""
|
||||
+169
@@ -0,0 +1,169 @@
|
||||
"""HTTP-слой: тонкие обработчики (SRP: только транспорт)."""
|
||||
import logging
|
||||
from typing import Optional
|
||||
|
||||
from fastapi import APIRouter, Depends, Header, Query, Request, Response
|
||||
|
||||
from app.auth import require_actor
|
||||
from app.db import Database
|
||||
from app.errors import unavailable, unsupported_media
|
||||
from app.schemas import CreateChatBody, CreateMessageBody, CreateUserBody
|
||||
from app.services import AuthService, ChatService, MessageService, UserService
|
||||
from app.sessions import SessionStore
|
||||
|
||||
logger = logging.getLogger("messenger")
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
def _state(request: Request):
|
||||
db: Database = request.app.state.db
|
||||
sessions: SessionStore = request.app.state.sessions
|
||||
return db, sessions
|
||||
|
||||
|
||||
def require_json_content_type(request: Request) -> None:
|
||||
content_type = request.headers.get("content-type", "")
|
||||
media = content_type.split(";")[0].strip().lower()
|
||||
if media != "application/json":
|
||||
raise unsupported_media()
|
||||
|
||||
|
||||
def _require_accepting(db: Database) -> None:
|
||||
if not db.accepting:
|
||||
raise unavailable("Сервер завершает работу")
|
||||
|
||||
|
||||
@router.get("/health/live")
|
||||
def live():
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@router.get("/health/ready")
|
||||
def ready(request: Request):
|
||||
db, sessions = _state(request)
|
||||
if not db.ready or not db.accepting:
|
||||
raise unavailable("Не готов принимать трафик")
|
||||
if not db.ping() or not sessions.ping():
|
||||
raise unavailable("Зависимость недоступна")
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@router.post("/api/v1/users", status_code=201)
|
||||
def create_user(
|
||||
request: Request,
|
||||
body: CreateUserBody,
|
||||
_: None = Depends(require_json_content_type),
|
||||
):
|
||||
db, _sessions = _state(request)
|
||||
_require_accepting(db)
|
||||
return UserService(db).create(body.model_dump())
|
||||
|
||||
|
||||
@router.post("/api/v1/auth/sessions", status_code=201)
|
||||
def create_session(
|
||||
request: Request,
|
||||
authorization: Optional[str] = Header(default=None),
|
||||
):
|
||||
db, sessions = _state(request)
|
||||
_require_accepting(db)
|
||||
return AuthService(db, sessions).create_session(authorization)
|
||||
|
||||
|
||||
@router.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
def revoke_session(
|
||||
request: Request,
|
||||
authorization: Optional[str] = Header(default=None),
|
||||
):
|
||||
db, sessions = _state(request)
|
||||
_require_accepting(db)
|
||||
_actor, token = require_actor(db, sessions, authorization)
|
||||
AuthService(db, sessions).logout(token)
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@router.get("/api/v1/users/me")
|
||||
def current_user(
|
||||
request: Request,
|
||||
authorization: Optional[str] = Header(default=None),
|
||||
):
|
||||
db, sessions = _state(request)
|
||||
_require_accepting(db)
|
||||
actor, _token = require_actor(db, sessions, authorization)
|
||||
return actor.to_dict()
|
||||
|
||||
|
||||
@router.post("/api/v1/chats", status_code=201)
|
||||
def create_chat(
|
||||
request: Request,
|
||||
body: CreateChatBody,
|
||||
authorization: Optional[str] = Header(default=None),
|
||||
_: None = Depends(require_json_content_type),
|
||||
):
|
||||
db, sessions = _state(request)
|
||||
_require_accepting(db)
|
||||
actor, _token = require_actor(db, sessions, authorization)
|
||||
return ChatService(db).create(actor, body.model_dump())
|
||||
|
||||
|
||||
@router.get("/api/v1/chats")
|
||||
def list_chats(
|
||||
request: Request,
|
||||
authorization: Optional[str] = Header(default=None),
|
||||
limit: Optional[str] = Query(default=None),
|
||||
cursor: Optional[str] = Query(default=None),
|
||||
):
|
||||
db, sessions = _state(request)
|
||||
_require_accepting(db)
|
||||
actor, _token = require_actor(db, sessions, authorization)
|
||||
return ChatService(db).list_for_user(actor, limit, cursor)
|
||||
|
||||
|
||||
@router.get("/api/v1/chats/{chat_id}")
|
||||
def get_chat(
|
||||
chat_id: str,
|
||||
request: Request,
|
||||
authorization: Optional[str] = Header(default=None),
|
||||
):
|
||||
db, sessions = _state(request)
|
||||
_require_accepting(db)
|
||||
actor, _token = require_actor(db, sessions, authorization)
|
||||
return ChatService(db).get_for_member(actor, chat_id).to_dict()
|
||||
|
||||
|
||||
@router.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
||||
def create_message(
|
||||
chat_id: str,
|
||||
request: Request,
|
||||
body: CreateMessageBody,
|
||||
authorization: Optional[str] = Header(default=None),
|
||||
_: None = Depends(require_json_content_type),
|
||||
):
|
||||
db, sessions = _state(request)
|
||||
_require_accepting(db)
|
||||
actor, _token = require_actor(db, sessions, authorization)
|
||||
chats = ChatService(db)
|
||||
chat = chats.get_for_member(actor, chat_id)
|
||||
result = MessageService(db).create(actor, chat, body.model_dump())
|
||||
logger.info(
|
||||
"message created chat_id=%s sender_id=%s message_id=%s",
|
||||
chat.id,
|
||||
actor.id,
|
||||
result["id"],
|
||||
)
|
||||
return result
|
||||
|
||||
|
||||
@router.get("/api/v1/chats/{chat_id}/messages")
|
||||
def list_messages(
|
||||
chat_id: str,
|
||||
request: Request,
|
||||
authorization: Optional[str] = Header(default=None),
|
||||
limit: Optional[str] = Query(default=None),
|
||||
cursor: Optional[str] = Query(default=None),
|
||||
):
|
||||
db, sessions = _state(request)
|
||||
_require_accepting(db)
|
||||
actor, _token = require_actor(db, sessions, authorization)
|
||||
chat = ChatService(db).get_for_member(actor, chat_id)
|
||||
return MessageService(db).list_for_chat(chat, limit, cursor)
|
||||
+64
@@ -0,0 +1,64 @@
|
||||
"""Разбор Basic/Bearer и проверка сессии."""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import binascii
|
||||
from typing import Optional, Tuple
|
||||
|
||||
from app.db import Database
|
||||
from app.errors import unauthorized
|
||||
from app.models import User
|
||||
from app.sessions import SessionStore
|
||||
from app.validation import USERNAME_RE
|
||||
|
||||
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
|
||||
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
def parse_basic(authorization: Optional[str]) -> Tuple[str, str]:
|
||||
if not authorization or not authorization.startswith("Basic "):
|
||||
raise unauthorized("Требуется Basic-аутентификация", challenge=BASIC_CHALLENGE)
|
||||
raw = authorization[6:].strip()
|
||||
if not raw:
|
||||
raise unauthorized("Требуется Basic-аутентификация", challenge=BASIC_CHALLENGE)
|
||||
try:
|
||||
decoded = base64.b64decode(raw, validate=True).decode("utf-8")
|
||||
except (binascii.Error, UnicodeDecodeError, ValueError) as exc:
|
||||
raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE) from exc
|
||||
if ":" not in decoded:
|
||||
raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE)
|
||||
username, password = decoded.split(":", 1)
|
||||
if not USERNAME_RE.fullmatch(username):
|
||||
raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE)
|
||||
n = len(password)
|
||||
if n < 12 or n > 128:
|
||||
raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE)
|
||||
return username, password
|
||||
|
||||
|
||||
def parse_bearer(authorization: Optional[str]) -> str:
|
||||
if not authorization:
|
||||
raise unauthorized(challenge=BEARER_CHALLENGE)
|
||||
if authorization.startswith("Basic "):
|
||||
raise unauthorized(challenge=BEARER_CHALLENGE)
|
||||
if not authorization.startswith("Bearer "):
|
||||
raise unauthorized(challenge=BEARER_CHALLENGE)
|
||||
token = authorization[7:].strip()
|
||||
if not token:
|
||||
raise unauthorized(challenge=BEARER_CHALLENGE)
|
||||
return token
|
||||
|
||||
|
||||
def require_actor(
|
||||
db: Database,
|
||||
sessions: SessionStore,
|
||||
authorization: Optional[str],
|
||||
) -> Tuple[User, str]:
|
||||
token = parse_bearer(authorization)
|
||||
user_id = sessions.resolve(token)
|
||||
if user_id is None:
|
||||
raise unauthorized(challenge=BEARER_CHALLENGE)
|
||||
user = db.get_user(user_id)
|
||||
if user is None:
|
||||
raise unauthorized(challenge=BEARER_CHALLENGE)
|
||||
return user, token
|
||||
@@ -0,0 +1,35 @@
|
||||
"""Конфигурация из окружения и secret-файлов."""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def _read_secret(file_env: str, direct_env: str) -> str:
|
||||
path = os.environ.get(file_env, "").strip()
|
||||
if path:
|
||||
return Path(path).read_text(encoding="utf-8").strip()
|
||||
value = os.environ.get(direct_env, "").strip()
|
||||
if value:
|
||||
return value
|
||||
raise RuntimeError(f"Задайте {file_env} или {direct_env}")
|
||||
|
||||
|
||||
class Settings:
|
||||
def __init__(self) -> None:
|
||||
self.host = os.environ.get("APP_HOST", "0.0.0.0")
|
||||
self.port = int(os.environ.get("APP_PORT", "8080"))
|
||||
self.env = os.environ.get("APP_ENV", "lab")
|
||||
self.session_ttl_seconds = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
|
||||
if self.session_ttl_seconds < 1:
|
||||
raise RuntimeError("SESSION_TTL_SECONDS должен быть >= 1")
|
||||
self.session_store = os.environ.get("SESSION_STORE", "redis").strip().lower()
|
||||
self.database_url = _read_secret("DATABASE_URL_FILE", "DATABASE_URL")
|
||||
self.cache_url = _read_secret("CACHE_URL_FILE", "CACHE_URL")
|
||||
self.db_connect_timeout = float(os.environ.get("DB_CONNECT_TIMEOUT", "5"))
|
||||
self.db_pool_min = int(os.environ.get("DB_POOL_MIN", "1"))
|
||||
self.db_pool_max = int(os.environ.get("DB_POOL_MAX", "10"))
|
||||
self.redis_socket_timeout = float(os.environ.get("REDIS_SOCKET_TIMEOUT", "3"))
|
||||
|
||||
|
||||
settings = Settings()
|
||||
@@ -0,0 +1,27 @@
|
||||
"""Непрозрачный keyset-cursor: (created_at, id), привязан к ресурсу."""
|
||||
import base64
|
||||
import json
|
||||
|
||||
from app.errors import invalid_request
|
||||
|
||||
|
||||
def encode(resource_id: str, created_at: str, item_id: str) -> str:
|
||||
payload = {"r": resource_id, "t": created_at, "i": item_id}
|
||||
raw = json.dumps(payload, separators=(",", ":")).encode("utf-8")
|
||||
return base64.urlsafe_b64encode(raw).decode("ascii")
|
||||
|
||||
|
||||
def decode(cursor: str, expected_resource_id: str) -> tuple:
|
||||
try:
|
||||
raw = base64.urlsafe_b64decode(cursor.encode("ascii"))
|
||||
payload = json.loads(raw.decode("utf-8"))
|
||||
resource_id = payload["r"]
|
||||
created_at = payload["t"]
|
||||
item_id = payload["i"]
|
||||
if not isinstance(resource_id, str) or not isinstance(created_at, str) or not isinstance(item_id, str):
|
||||
raise ValueError("bad types")
|
||||
except Exception as exc:
|
||||
raise invalid_request("Неверный cursor") from exc
|
||||
if resource_id != expected_resource_id:
|
||||
raise invalid_request("Cursor относится к другому ресурсу")
|
||||
return created_at, item_id
|
||||
@@ -0,0 +1,376 @@
|
||||
"""PostgreSQL pool, миграции и параметризованные запросы."""
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from pathlib import Path
|
||||
from typing import List, Optional, Sequence
|
||||
|
||||
from psycopg import OperationalError
|
||||
from psycopg.errors import UniqueViolation
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import ConnectionPool
|
||||
|
||||
from app.config import settings
|
||||
from app.errors import unavailable
|
||||
from app.models import Chat, Message, User
|
||||
from app.timefmt import format_utc
|
||||
|
||||
logger = logging.getLogger("messenger")
|
||||
|
||||
MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations"
|
||||
|
||||
|
||||
class Database:
|
||||
def __init__(self) -> None:
|
||||
self.pool: Optional[ConnectionPool] = None
|
||||
self.accepting = True
|
||||
self.ready = False
|
||||
|
||||
def open(self) -> None:
|
||||
self.pool = ConnectionPool(
|
||||
conninfo=settings.database_url,
|
||||
min_size=settings.db_pool_min,
|
||||
max_size=settings.db_pool_max,
|
||||
timeout=settings.db_connect_timeout,
|
||||
kwargs={
|
||||
"connect_timeout": max(1, int(settings.db_connect_timeout)),
|
||||
"row_factory": dict_row,
|
||||
},
|
||||
open=True,
|
||||
)
|
||||
self.apply_migrations()
|
||||
self.ready = True
|
||||
logger.info("postgres pool ready; migrations applied")
|
||||
|
||||
def close(self) -> None:
|
||||
self.ready = False
|
||||
self.accepting = False
|
||||
if self.pool is not None:
|
||||
self.pool.close()
|
||||
self.pool = None
|
||||
|
||||
def begin_shutdown(self) -> None:
|
||||
self.accepting = False
|
||||
self.ready = False
|
||||
|
||||
def _require_pool(self) -> ConnectionPool:
|
||||
if self.pool is None:
|
||||
raise unavailable("База данных недоступна")
|
||||
return self.pool
|
||||
|
||||
def ping(self) -> bool:
|
||||
try:
|
||||
pool = self._require_pool()
|
||||
with pool.connection() as conn:
|
||||
conn.execute("SELECT 1")
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
@staticmethod
|
||||
def _split_sql(script: str) -> List[str]:
|
||||
statements: List[str] = []
|
||||
buf: List[str] = []
|
||||
for line in script.splitlines():
|
||||
stripped = line.strip()
|
||||
if not stripped or stripped.startswith("--"):
|
||||
continue
|
||||
buf.append(line)
|
||||
if stripped.endswith(";"):
|
||||
stmt = "\n".join(buf).strip()
|
||||
if stmt:
|
||||
statements.append(stmt)
|
||||
buf = []
|
||||
tail = "\n".join(buf).strip()
|
||||
if tail:
|
||||
statements.append(tail)
|
||||
return statements
|
||||
|
||||
def apply_migrations(self) -> None:
|
||||
pool = self._require_pool()
|
||||
files = sorted(MIGRATIONS_DIR.glob("*.sql"))
|
||||
with pool.connection() as conn:
|
||||
conn.execute(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version TEXT PRIMARY KEY,
|
||||
applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
)
|
||||
"""
|
||||
)
|
||||
for path in files:
|
||||
version = path.name
|
||||
row = conn.execute(
|
||||
"SELECT 1 FROM schema_migrations WHERE version = %s",
|
||||
(version,),
|
||||
).fetchone()
|
||||
if row:
|
||||
continue
|
||||
statements = self._split_sql(path.read_text(encoding="utf-8"))
|
||||
with conn.transaction():
|
||||
for stmt in statements:
|
||||
conn.execute(stmt)
|
||||
conn.execute(
|
||||
"INSERT INTO schema_migrations (version) VALUES (%s)",
|
||||
(version,),
|
||||
)
|
||||
logger.info("applied migration %s", version)
|
||||
|
||||
def _user_from_row(self, row: dict) -> User:
|
||||
return User(
|
||||
id=str(row["id"]),
|
||||
username=row["username"],
|
||||
display_name=row["display_name"],
|
||||
created_at=format_utc(row["created_at"]),
|
||||
password_hash=row.get("password_hash", ""),
|
||||
)
|
||||
|
||||
def add_user(self, user: User) -> None:
|
||||
pool = self._require_pool()
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES (%s, %s, %s, %s, %s::timestamptz)
|
||||
""",
|
||||
(
|
||||
user.id,
|
||||
user.username,
|
||||
user.display_name,
|
||||
user.password_hash,
|
||||
user.created_at,
|
||||
),
|
||||
)
|
||||
except UniqueViolation as exc:
|
||||
raise KeyError("username") from exc
|
||||
except OperationalError as exc:
|
||||
raise unavailable("База данных недоступна") from exc
|
||||
|
||||
def get_user(self, user_id: str) -> Optional[User]:
|
||||
pool = self._require_pool()
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT id, username, display_name, password_hash, created_at
|
||||
FROM users WHERE id = %s
|
||||
""",
|
||||
(user_id,),
|
||||
).fetchone()
|
||||
except OperationalError as exc:
|
||||
raise unavailable("База данных недоступна") from exc
|
||||
return self._user_from_row(row) if row else None
|
||||
|
||||
def get_user_by_username(self, username: str) -> Optional[User]:
|
||||
pool = self._require_pool()
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT id, username, display_name, password_hash, created_at
|
||||
FROM users WHERE username = %s
|
||||
""",
|
||||
(username,),
|
||||
).fetchone()
|
||||
except OperationalError as exc:
|
||||
raise unavailable("База данных недоступна") from exc
|
||||
return self._user_from_row(row) if row else None
|
||||
|
||||
def users_exist(self, user_ids: Sequence[str]) -> bool:
|
||||
if not user_ids:
|
||||
return True
|
||||
pool = self._require_pool()
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"SELECT COUNT(*) AS c FROM users WHERE id = ANY(%s::uuid[])",
|
||||
(list(user_ids),),
|
||||
).fetchone()
|
||||
except OperationalError as exc:
|
||||
raise unavailable("База данных недоступна") from exc
|
||||
return int(row["c"]) == len(set(user_ids))
|
||||
|
||||
def add_chat(self, chat: Chat) -> None:
|
||||
"""Атомарно: чат + участники в одной транзакции."""
|
||||
pool = self._require_pool()
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
with conn.transaction():
|
||||
# Повторная проверка участников внутри транзакции.
|
||||
row = conn.execute(
|
||||
"SELECT COUNT(*) AS c FROM users WHERE id = ANY(%s::uuid[])",
|
||||
(list(chat.member_ids),),
|
||||
).fetchone()
|
||||
if int(row["c"]) != len(set(chat.member_ids)):
|
||||
raise ValueError("unknown member")
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO chats (id, title, created_at)
|
||||
VALUES (%s, %s, %s::timestamptz)
|
||||
""",
|
||||
(chat.id, chat.title, chat.created_at),
|
||||
)
|
||||
for mid in chat.member_ids:
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO chat_members (chat_id, user_id)
|
||||
VALUES (%s, %s)
|
||||
""",
|
||||
(chat.id, mid),
|
||||
)
|
||||
except ValueError:
|
||||
raise
|
||||
except OperationalError as exc:
|
||||
raise unavailable("База данных недоступна") from exc
|
||||
|
||||
def get_chat(self, chat_id: str) -> Optional[Chat]:
|
||||
pool = self._require_pool()
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"SELECT id, title, created_at FROM chats WHERE id = %s",
|
||||
(chat_id,),
|
||||
).fetchone()
|
||||
if not row:
|
||||
return None
|
||||
members = conn.execute(
|
||||
"""
|
||||
SELECT user_id FROM chat_members
|
||||
WHERE chat_id = %s
|
||||
ORDER BY user_id
|
||||
""",
|
||||
(chat_id,),
|
||||
).fetchall()
|
||||
except OperationalError as exc:
|
||||
raise unavailable("База данных недоступна") from exc
|
||||
return Chat(
|
||||
id=str(row["id"]),
|
||||
title=row["title"],
|
||||
member_ids=[str(m["user_id"]) for m in members],
|
||||
created_at=format_utc(row["created_at"]),
|
||||
)
|
||||
|
||||
def list_chats_for(self, user_id: str) -> List[Chat]:
|
||||
pool = self._require_pool()
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT c.id, c.title, c.created_at
|
||||
FROM chats c
|
||||
JOIN chat_members m ON m.chat_id = c.id
|
||||
WHERE m.user_id = %s
|
||||
ORDER BY c.created_at ASC, c.id ASC
|
||||
""",
|
||||
(user_id,),
|
||||
).fetchall()
|
||||
result: List[Chat] = []
|
||||
for row in rows:
|
||||
members = conn.execute(
|
||||
"""
|
||||
SELECT user_id FROM chat_members
|
||||
WHERE chat_id = %s
|
||||
ORDER BY user_id
|
||||
""",
|
||||
(row["id"],),
|
||||
).fetchall()
|
||||
result.append(
|
||||
Chat(
|
||||
id=str(row["id"]),
|
||||
title=row["title"],
|
||||
member_ids=[str(m["user_id"]) for m in members],
|
||||
created_at=format_utc(row["created_at"]),
|
||||
)
|
||||
)
|
||||
return result
|
||||
except OperationalError as exc:
|
||||
raise unavailable("База данных недоступна") from exc
|
||||
|
||||
def add_message(self, message: Message) -> Message:
|
||||
pool = self._require_pool()
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
VALUES (%s, %s, %s, %s, %s::timestamptz)
|
||||
""",
|
||||
(
|
||||
message.id,
|
||||
message.chat_id,
|
||||
message.sender_id,
|
||||
message.text,
|
||||
message.created_at,
|
||||
),
|
||||
)
|
||||
except OperationalError as exc:
|
||||
raise unavailable("База данных недоступна") from exc
|
||||
return message
|
||||
|
||||
def list_messages_page(
|
||||
self,
|
||||
chat_id: str,
|
||||
limit: int,
|
||||
after_created_at: Optional[str] = None,
|
||||
after_id: Optional[str] = None,
|
||||
) -> List[Message]:
|
||||
"""Keyset page using index (chat_id, created_at, id)."""
|
||||
pool = self._require_pool()
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
if after_created_at is None:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = %s
|
||||
ORDER BY created_at ASC, id ASC
|
||||
LIMIT %s
|
||||
""",
|
||||
(chat_id, limit),
|
||||
).fetchall()
|
||||
else:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = %s
|
||||
AND (created_at, id) > (%s::timestamptz, %s::uuid)
|
||||
ORDER BY created_at ASC, id ASC
|
||||
LIMIT %s
|
||||
""",
|
||||
(chat_id, after_created_at, after_id, limit),
|
||||
).fetchall()
|
||||
except OperationalError as exc:
|
||||
raise unavailable("База данных недоступна") from exc
|
||||
return [
|
||||
Message(
|
||||
id=str(r["id"]),
|
||||
chat_id=str(r["chat_id"]),
|
||||
sender_id=str(r["sender_id"]),
|
||||
text=r["text"],
|
||||
created_at=format_utc(r["created_at"]),
|
||||
)
|
||||
for r in rows
|
||||
]
|
||||
|
||||
def explain_messages_page(self, chat_id: str, limit: int = 50) -> str:
|
||||
pool = self._require_pool()
|
||||
with pool.connection() as conn:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
EXPLAIN (ANALYZE, BUFFERS, FORMAT TEXT)
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = %s
|
||||
ORDER BY created_at ASC, id ASC
|
||||
LIMIT %s
|
||||
""",
|
||||
(chat_id, limit),
|
||||
).fetchall()
|
||||
# EXPLAIN text rows come as single-column dicts
|
||||
lines = []
|
||||
for r in rows:
|
||||
lines.append(next(iter(r.values())))
|
||||
return "\n".join(lines)
|
||||
@@ -0,0 +1,54 @@
|
||||
"""Единый формат ошибок API."""
|
||||
from typing import Optional
|
||||
|
||||
|
||||
class AppError(Exception):
|
||||
def __init__(
|
||||
self,
|
||||
status: int,
|
||||
code: str,
|
||||
message: str,
|
||||
headers: Optional[dict] = None,
|
||||
) -> None:
|
||||
self.status = status
|
||||
self.code = code
|
||||
self.message = message
|
||||
self.headers = headers or {}
|
||||
super().__init__(message)
|
||||
|
||||
|
||||
def invalid_request(message: str = "Неверный запрос") -> AppError:
|
||||
return AppError(400, "invalid_request", message)
|
||||
|
||||
|
||||
def unauthorized(
|
||||
message: str = "Требуется идентификация",
|
||||
*,
|
||||
challenge: str = 'Bearer realm="messenger"',
|
||||
) -> AppError:
|
||||
return AppError(
|
||||
401,
|
||||
"unauthorized",
|
||||
message,
|
||||
headers={"WWW-Authenticate": challenge},
|
||||
)
|
||||
|
||||
|
||||
def not_found(message: str = "Объект не найден") -> AppError:
|
||||
return AppError(404, "not_found", message)
|
||||
|
||||
|
||||
def conflict(message: str = "Конфликт") -> AppError:
|
||||
return AppError(409, "conflict", message)
|
||||
|
||||
|
||||
def unsupported_media(message: str = "Неподдерживаемый Content-Type") -> AppError:
|
||||
return AppError(415, "unsupported_media_type", message)
|
||||
|
||||
|
||||
def unavailable(message: str = "Сервис недоступен") -> AppError:
|
||||
return AppError(503, "unavailable", message)
|
||||
|
||||
|
||||
def error_body(code: str, message: str, request_id: str) -> dict:
|
||||
return {"error": {"code": code, "message": message, "request_id": request_id}}
|
||||
+112
@@ -0,0 +1,112 @@
|
||||
"""Точка входа HTTP-приложения lab2."""
|
||||
import logging
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse
|
||||
from starlette.middleware.base import BaseHTTPMiddleware
|
||||
|
||||
from app.api import router
|
||||
from app.db import Database
|
||||
from app.errors import AppError, error_body
|
||||
from app.sessions import SessionStore
|
||||
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s %(levelname)s %(name)s %(message)s",
|
||||
)
|
||||
logger = logging.getLogger("messenger")
|
||||
|
||||
db = Database()
|
||||
sessions = SessionStore()
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(_app: FastAPI):
|
||||
logger.info("server starting; connecting to postgres/redis")
|
||||
db.open()
|
||||
sessions.open()
|
||||
_app.state.db = db
|
||||
_app.state.sessions = sessions
|
||||
logger.info("dependencies ready")
|
||||
yield
|
||||
db.begin_shutdown()
|
||||
sessions.close()
|
||||
db.close()
|
||||
logger.info("SIGTERM/shutdown: stop accepting, ready=false")
|
||||
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger lab2", lifespan=lifespan)
|
||||
app.state.db = db
|
||||
app.state.sessions = sessions
|
||||
app.include_router(router)
|
||||
|
||||
|
||||
class RequestIdMiddleware(BaseHTTPMiddleware):
|
||||
async def dispatch(self, request: Request, call_next):
|
||||
request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
|
||||
request.state.request_id = request_id
|
||||
response = await call_next(request)
|
||||
response.headers["X-Request-Id"] = request_id
|
||||
logger.info(
|
||||
"%s %s -> %s request_id=%s",
|
||||
request.method,
|
||||
request.url.path,
|
||||
response.status_code,
|
||||
request_id,
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
app.add_middleware(RequestIdMiddleware)
|
||||
|
||||
|
||||
@app.exception_handler(AppError)
|
||||
async def app_error_handler(request: Request, exc: AppError):
|
||||
request_id = getattr(request.state, "request_id", None) or str(uuid.uuid4())
|
||||
headers = {"X-Request-Id": request_id}
|
||||
headers.update(exc.headers)
|
||||
return JSONResponse(
|
||||
status_code=exc.status,
|
||||
content=error_body(exc.code, exc.message, request_id),
|
||||
headers=headers,
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_handler(request: Request, _exc: RequestValidationError):
|
||||
request_id = getattr(request.state, "request_id", None) or str(uuid.uuid4())
|
||||
return JSONResponse(
|
||||
status_code=400,
|
||||
content=error_body("invalid_request", "Неверный запрос", request_id),
|
||||
headers={"X-Request-Id": request_id},
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def internal_handler(request: Request, exc: Exception):
|
||||
request_id = getattr(request.state, "request_id", None) or str(uuid.uuid4())
|
||||
logger.exception("unhandled error request_id=%s", request_id)
|
||||
return JSONResponse(
|
||||
status_code=500,
|
||||
content=error_body("internal_error", "Внутренняя ошибка", request_id),
|
||||
headers={"X-Request-Id": request_id},
|
||||
)
|
||||
|
||||
|
||||
def run() -> None:
|
||||
import uvicorn
|
||||
from app.config import settings
|
||||
|
||||
uvicorn.run(
|
||||
"app.main:app",
|
||||
host=settings.host,
|
||||
port=settings.port,
|
||||
log_level="info",
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run()
|
||||
@@ -0,0 +1,58 @@
|
||||
"""Доменные сущности (данные, без HTTP и без бизнес-правил)."""
|
||||
import uuid
|
||||
from dataclasses import dataclass
|
||||
from typing import List
|
||||
|
||||
|
||||
@dataclass
|
||||
class User:
|
||||
id: str
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: str
|
||||
password_hash: str = ""
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
return {
|
||||
"id": self.id,
|
||||
"username": self.username,
|
||||
"display_name": self.display_name,
|
||||
"created_at": self.created_at,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class Chat:
|
||||
id: str
|
||||
title: str
|
||||
member_ids: List[str]
|
||||
created_at: str
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
return {
|
||||
"id": self.id,
|
||||
"title": self.title,
|
||||
"member_ids": list(self.member_ids),
|
||||
"created_at": self.created_at,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class Message:
|
||||
id: str
|
||||
chat_id: str
|
||||
sender_id: str
|
||||
text: str
|
||||
created_at: str
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
return {
|
||||
"id": self.id,
|
||||
"chat_id": self.chat_id,
|
||||
"sender_id": self.sender_id,
|
||||
"text": self.text,
|
||||
"created_at": self.created_at,
|
||||
}
|
||||
|
||||
def sort_key(self):
|
||||
return (self.created_at, uuid.UUID(self.id).int)
|
||||
@@ -0,0 +1,18 @@
|
||||
"""Password KDF: Argon2id (библиотечный)."""
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import VerifyMismatchError
|
||||
|
||||
_hasher = PasswordHasher()
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
return _hasher.hash(password)
|
||||
|
||||
|
||||
def verify_password(password_hash: str, password: str) -> bool:
|
||||
try:
|
||||
return _hasher.verify(password_hash, password)
|
||||
except VerifyMismatchError:
|
||||
return False
|
||||
except Exception:
|
||||
return False
|
||||
@@ -0,0 +1,28 @@
|
||||
"""Схемы тел запросов для OpenAPI / Swagger (валидация домена — в services)."""
|
||||
from typing import List
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field
|
||||
|
||||
|
||||
class CreateUserBody(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
username: str = Field(..., examples=["alice"])
|
||||
display_name: str = Field(..., examples=["Алиса"])
|
||||
password: str = Field(..., examples=["Example-only-not-a-real-secret-123"])
|
||||
|
||||
|
||||
class CreateChatBody(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
title: str = Field(..., examples=["Проект по ВНП"])
|
||||
member_ids: List[str] = Field(
|
||||
...,
|
||||
examples=[["11111111-1111-4111-8111-111111111111"]],
|
||||
)
|
||||
|
||||
|
||||
class CreateMessageBody(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
text: str = Field(..., examples=["Привет, Боб!"])
|
||||
+187
@@ -0,0 +1,187 @@
|
||||
"""Бизнес-логика lab2 (DIP: зависит от Database/SessionStore)."""
|
||||
from __future__ import annotations
|
||||
|
||||
import uuid
|
||||
from typing import List, Optional
|
||||
|
||||
from app import cursor as cursor_util
|
||||
from app.auth import BASIC_CHALLENGE, parse_basic
|
||||
from app.db import Database
|
||||
from app.errors import conflict, invalid_request, not_found, unauthorized
|
||||
from app.models import Chat, Message, User
|
||||
from app.password import hash_password, verify_password
|
||||
from app.sessions import SessionStore
|
||||
from app.timefmt import now_utc
|
||||
from app.validation import (
|
||||
parse_limit,
|
||||
parse_uuid,
|
||||
reject_unknown,
|
||||
require_display_name,
|
||||
require_keys,
|
||||
require_message_text,
|
||||
require_object,
|
||||
require_password,
|
||||
require_title,
|
||||
require_username,
|
||||
)
|
||||
|
||||
|
||||
class UserService:
|
||||
def __init__(self, db: Database) -> None:
|
||||
self.db = db
|
||||
|
||||
def create(self, body: object) -> dict:
|
||||
data = require_object(body)
|
||||
reject_unknown(data, {"username", "display_name", "password"})
|
||||
require_keys(data, ("username", "display_name", "password"))
|
||||
username = require_username(data["username"])
|
||||
display_name = require_display_name(data["display_name"])
|
||||
password = require_password(data["password"])
|
||||
user = User(
|
||||
id=str(uuid.uuid4()),
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
created_at=now_utc(),
|
||||
password_hash=hash_password(password),
|
||||
)
|
||||
try:
|
||||
self.db.add_user(user)
|
||||
except KeyError as exc:
|
||||
raise conflict("username уже занят") from exc
|
||||
return user.to_dict()
|
||||
|
||||
|
||||
class AuthService:
|
||||
def __init__(self, db: Database, sessions: SessionStore) -> None:
|
||||
self.db = db
|
||||
self.sessions = sessions
|
||||
|
||||
def create_session(self, authorization: Optional[str]) -> dict:
|
||||
username, password = parse_basic(authorization)
|
||||
user = self.db.get_user_by_username(username)
|
||||
if user is None or not verify_password(user.password_hash, password):
|
||||
raise unauthorized("Неверные учётные данные", challenge=BASIC_CHALLENGE)
|
||||
token, expires_at = self.sessions.create(user.id)
|
||||
return {
|
||||
"token": token,
|
||||
"token_type": "Bearer",
|
||||
"expires_at": expires_at,
|
||||
"user": user.to_dict(),
|
||||
}
|
||||
|
||||
def logout(self, token: str) -> None:
|
||||
self.sessions.revoke(token)
|
||||
|
||||
|
||||
class ChatService:
|
||||
def __init__(self, db: Database) -> None:
|
||||
self.db = db
|
||||
|
||||
def create(self, actor: User, body: object) -> dict:
|
||||
data = require_object(body)
|
||||
reject_unknown(data, {"title", "member_ids"})
|
||||
require_keys(data, ("title", "member_ids"))
|
||||
title = require_title(data["title"])
|
||||
raw_members = data["member_ids"]
|
||||
if not isinstance(raw_members, list):
|
||||
raise invalid_request("member_ids должен быть массивом")
|
||||
if len(raw_members) < 1 or len(raw_members) > 100:
|
||||
raise invalid_request("member_ids: от 1 до 100 участников")
|
||||
member_ids: List[str] = []
|
||||
seen = set()
|
||||
for item in raw_members:
|
||||
mid = parse_uuid(item, "member_ids")
|
||||
if mid in seen:
|
||||
raise invalid_request("member_ids содержит дубликаты")
|
||||
seen.add(mid)
|
||||
member_ids.append(mid)
|
||||
if actor.id not in seen:
|
||||
raise invalid_request("Вызывающий должен быть в member_ids")
|
||||
if not self.db.users_exist(member_ids):
|
||||
raise invalid_request("Неизвестный участник")
|
||||
chat = Chat(
|
||||
id=str(uuid.uuid4()),
|
||||
title=title,
|
||||
member_ids=member_ids,
|
||||
created_at=now_utc(),
|
||||
)
|
||||
try:
|
||||
self.db.add_chat(chat)
|
||||
except ValueError as exc:
|
||||
raise invalid_request("Неизвестный участник") from exc
|
||||
return chat.to_dict()
|
||||
|
||||
def get_for_member(self, actor: User, chat_id: str) -> Chat:
|
||||
cid = parse_uuid(chat_id, "chat_id")
|
||||
chat = self.db.get_chat(cid)
|
||||
if chat is None or actor.id not in chat.member_ids:
|
||||
raise not_found()
|
||||
return chat
|
||||
|
||||
def list_for_user(self, actor: User, limit_raw: Optional[str], cursor_raw: Optional[str]) -> dict:
|
||||
limit = parse_limit(limit_raw)
|
||||
chats = self.db.list_chats_for(actor.id)
|
||||
start = 0
|
||||
if cursor_raw:
|
||||
created_at, item_id = cursor_util.decode(cursor_raw, actor.id)
|
||||
start = 0
|
||||
for i, chat in enumerate(chats):
|
||||
if (chat.created_at, chat.id) > (created_at, item_id):
|
||||
start = i
|
||||
break
|
||||
else:
|
||||
start = len(chats)
|
||||
page = chats[start : start + limit]
|
||||
next_cursor = None
|
||||
if start + limit < len(chats) and page:
|
||||
last = page[-1]
|
||||
next_cursor = cursor_util.encode(actor.id, last.created_at, last.id)
|
||||
return {"items": [c.to_dict() for c in page], "next_cursor": next_cursor}
|
||||
|
||||
|
||||
class MessageService:
|
||||
def __init__(self, db: Database) -> None:
|
||||
self.db = db
|
||||
|
||||
def create(self, actor: User, chat: Chat, body: object) -> dict:
|
||||
data = require_object(body)
|
||||
reject_unknown(data, {"text"})
|
||||
require_keys(data, ("text",))
|
||||
text = require_message_text(data["text"])
|
||||
message = Message(
|
||||
id=str(uuid.uuid4()),
|
||||
chat_id=chat.id,
|
||||
sender_id=actor.id,
|
||||
text=text,
|
||||
created_at=now_utc(),
|
||||
)
|
||||
self.db.add_message(message)
|
||||
return message.to_dict()
|
||||
|
||||
def list_for_chat(
|
||||
self,
|
||||
chat: Chat,
|
||||
limit_raw: Optional[str],
|
||||
cursor_raw: Optional[str],
|
||||
) -> dict:
|
||||
limit = parse_limit(limit_raw)
|
||||
after_created_at = None
|
||||
after_id = None
|
||||
if cursor_raw:
|
||||
created_at, item_id = cursor_util.decode(cursor_raw, chat.id)
|
||||
parse_uuid(item_id, "cursor.id")
|
||||
after_created_at = created_at
|
||||
after_id = item_id
|
||||
# Fetch limit+1 to detect next page without scanning all history.
|
||||
rows = self.db.list_messages_page(
|
||||
chat.id,
|
||||
limit + 1,
|
||||
after_created_at=after_created_at,
|
||||
after_id=after_id,
|
||||
)
|
||||
page = rows[:limit]
|
||||
next_cursor = None
|
||||
if len(rows) > limit and page:
|
||||
last = page[-1]
|
||||
next_cursor = cursor_util.encode(chat.id, last.created_at, last.id)
|
||||
return {"items": [m.to_dict() for m in page], "next_cursor": next_cursor}
|
||||
@@ -0,0 +1,93 @@
|
||||
"""Opaque Bearer-сессии в Redis с TTL и AOF-persistence на стороне Redis."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import secrets
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import Optional, Tuple
|
||||
|
||||
import redis
|
||||
|
||||
from app.config import settings
|
||||
from app.errors import unavailable
|
||||
from app.timefmt import format_utc, parse_rfc3339
|
||||
|
||||
logger = logging.getLogger("messenger")
|
||||
|
||||
TOKEN_PREFIX = "session:"
|
||||
|
||||
|
||||
class SessionStore:
|
||||
def __init__(self) -> None:
|
||||
self.client: Optional[redis.Redis] = None
|
||||
|
||||
def open(self) -> None:
|
||||
self.client = redis.Redis.from_url(
|
||||
settings.cache_url,
|
||||
decode_responses=True,
|
||||
socket_connect_timeout=settings.redis_socket_timeout,
|
||||
socket_timeout=settings.redis_socket_timeout,
|
||||
)
|
||||
self.client.ping()
|
||||
logger.info("redis session store ready")
|
||||
|
||||
def close(self) -> None:
|
||||
if self.client is not None:
|
||||
self.client.close()
|
||||
self.client = None
|
||||
|
||||
def _require(self) -> redis.Redis:
|
||||
if self.client is None:
|
||||
raise unavailable("Хранилище сессий недоступно")
|
||||
return self.client
|
||||
|
||||
def ping(self) -> bool:
|
||||
try:
|
||||
return bool(self._require().ping())
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
def create(self, user_id: str) -> Tuple[str, str]:
|
||||
"""Возвращает (token, expires_at)."""
|
||||
client = self._require()
|
||||
token = secrets.token_urlsafe(32) # ≥256 бит
|
||||
expires = datetime.now(timezone.utc) + timedelta(seconds=settings.session_ttl_seconds)
|
||||
expires_at = format_utc(expires)
|
||||
payload = json.dumps({"user_id": user_id, "expires_at": expires_at}, separators=(",", ":"))
|
||||
try:
|
||||
client.setex(TOKEN_PREFIX + token, settings.session_ttl_seconds, payload)
|
||||
except redis.RedisError as exc:
|
||||
raise unavailable("Хранилище сессий недоступно") from exc
|
||||
return token, expires_at
|
||||
|
||||
def resolve(self, token: str) -> Optional[str]:
|
||||
"""user_id или None, если нет/истекла. 503 при недоступности Redis."""
|
||||
client = self._require()
|
||||
try:
|
||||
raw = client.get(TOKEN_PREFIX + token)
|
||||
except redis.RedisError as exc:
|
||||
raise unavailable("Хранилище сессий недоступно") from exc
|
||||
if not raw:
|
||||
return None
|
||||
try:
|
||||
data = json.loads(raw)
|
||||
user_id = data["user_id"]
|
||||
expires_at = parse_rfc3339(data["expires_at"])
|
||||
except Exception:
|
||||
return None
|
||||
if expires_at <= datetime.now(timezone.utc):
|
||||
try:
|
||||
client.delete(TOKEN_PREFIX + token)
|
||||
except redis.RedisError:
|
||||
pass
|
||||
return None
|
||||
return str(user_id)
|
||||
|
||||
def revoke(self, token: str) -> bool:
|
||||
client = self._require()
|
||||
try:
|
||||
deleted = client.delete(TOKEN_PREFIX + token)
|
||||
except redis.RedisError as exc:
|
||||
raise unavailable("Хранилище сессий недоступно") from exc
|
||||
return bool(deleted)
|
||||
@@ -0,0 +1,20 @@
|
||||
"""Форматирование времени в RFC 3339 UTC с миллисекундами и Z."""
|
||||
from datetime import datetime, timezone
|
||||
|
||||
|
||||
def now_utc() -> str:
|
||||
return format_utc(datetime.now(timezone.utc))
|
||||
|
||||
|
||||
def format_utc(value: datetime) -> str:
|
||||
if value.tzinfo is None:
|
||||
value = value.replace(tzinfo=timezone.utc)
|
||||
else:
|
||||
value = value.astimezone(timezone.utc)
|
||||
return value.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
|
||||
|
||||
|
||||
def parse_rfc3339(value: str) -> datetime:
|
||||
if value.endswith("Z"):
|
||||
value = value[:-1] + "+00:00"
|
||||
return datetime.fromisoformat(value)
|
||||
@@ -0,0 +1,102 @@
|
||||
"""Проверки входных данных по контракту lab2."""
|
||||
import re
|
||||
import uuid
|
||||
from typing import Any, Iterable, Optional, Set
|
||||
|
||||
from app.errors import invalid_request
|
||||
|
||||
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
|
||||
|
||||
|
||||
def require_object(body: Any) -> dict:
|
||||
if not isinstance(body, dict):
|
||||
raise invalid_request("Тело запроса должно быть JSON-объектом")
|
||||
return body
|
||||
|
||||
|
||||
def reject_unknown(body: dict, allowed: Set[str]) -> None:
|
||||
extra = set(body) - allowed
|
||||
if extra:
|
||||
raise invalid_request("Лишние поля в запросе")
|
||||
|
||||
|
||||
def require_keys(body: dict, keys: Iterable[str]) -> None:
|
||||
for key in keys:
|
||||
if key not in body:
|
||||
raise invalid_request(f"Поле {key} обязательно")
|
||||
|
||||
|
||||
def parse_uuid(value: Any, field: str = "id") -> str:
|
||||
if not isinstance(value, str):
|
||||
raise invalid_request(f"Поле {field} должно быть UUID-строкой")
|
||||
try:
|
||||
return str(uuid.UUID(value))
|
||||
except ValueError as exc:
|
||||
raise invalid_request(f"Неверный UUID: {field}") from exc
|
||||
|
||||
|
||||
def code_points(text: str) -> int:
|
||||
return len(text)
|
||||
|
||||
|
||||
def require_username(value: Any) -> str:
|
||||
if not isinstance(value, str):
|
||||
raise invalid_request("username должен быть строкой")
|
||||
if not USERNAME_RE.fullmatch(value):
|
||||
raise invalid_request("username: только [a-z0-9_] длиной 3–32")
|
||||
return value
|
||||
|
||||
|
||||
def require_display_name(value: Any) -> str:
|
||||
if not isinstance(value, str):
|
||||
raise invalid_request("display_name должен быть строкой")
|
||||
if value.strip() == "":
|
||||
raise invalid_request("display_name не может быть пустым")
|
||||
n = code_points(value)
|
||||
if n < 1 or n > 100:
|
||||
raise invalid_request("display_name: 1–100 символов Unicode")
|
||||
return value
|
||||
|
||||
|
||||
def require_password(value: Any) -> str:
|
||||
if not isinstance(value, str):
|
||||
raise invalid_request("password должен быть строкой")
|
||||
if value.strip() == "":
|
||||
raise invalid_request("password не может быть пустым")
|
||||
n = code_points(value)
|
||||
if n < 12 or n > 128:
|
||||
raise invalid_request("password: 12–128 символов Unicode")
|
||||
return value
|
||||
|
||||
|
||||
def require_title(value: Any) -> str:
|
||||
if not isinstance(value, str):
|
||||
raise invalid_request("title должен быть строкой")
|
||||
if value.strip() == "":
|
||||
raise invalid_request("title не может быть пустым")
|
||||
n = code_points(value)
|
||||
if n < 1 or n > 100:
|
||||
raise invalid_request("title: 1–100 символов Unicode")
|
||||
return value
|
||||
|
||||
|
||||
def require_message_text(value: Any) -> str:
|
||||
if not isinstance(value, str):
|
||||
raise invalid_request("text должен быть строкой")
|
||||
if value.strip() == "":
|
||||
raise invalid_request("text не может быть пустым")
|
||||
if code_points(value) > 4000:
|
||||
raise invalid_request("text: максимум 4000 символов Unicode")
|
||||
return value
|
||||
|
||||
|
||||
def parse_limit(raw: Optional[str], default: int = 50) -> int:
|
||||
if raw is None or raw == "":
|
||||
return default
|
||||
try:
|
||||
value = int(raw)
|
||||
except ValueError as exc:
|
||||
raise invalid_request("limit должен быть целым числом") from exc
|
||||
if value < 1 or value > 100:
|
||||
raise invalid_request("limit должен быть от 1 до 100")
|
||||
return value
|
||||
@@ -0,0 +1,95 @@
|
||||
# Runnable lab2 stand: API + PostgreSQL + Redis (sessions with AOF).
|
||||
x-lab-number: 2
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.4-bookworm
|
||||
environment:
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
|
||||
POSTGRES_DB: messenger
|
||||
ports:
|
||||
- "127.0.0.1:15432:5432"
|
||||
secrets:
|
||||
- postgres_password
|
||||
volumes:
|
||||
- pg_data:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
restart: unless-stopped
|
||||
|
||||
redis:
|
||||
image: redis:7.4.1-bookworm
|
||||
command:
|
||||
- redis-server
|
||||
- --appendonly
|
||||
- "yes"
|
||||
- --appendfsync
|
||||
- everysec
|
||||
- --dir
|
||||
- /data
|
||||
ports:
|
||||
- "127.0.0.1:6379:6379"
|
||||
volumes:
|
||||
- redis_data:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
restart: unless-stopped
|
||||
|
||||
api:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
environment:
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: "8080"
|
||||
APP_ENV: lab
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
SESSION_STORE: redis
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
CACHE_URL_FILE: /run/secrets/cache_url
|
||||
DB_CONNECT_TIMEOUT: "5"
|
||||
DB_POOL_MIN: "1"
|
||||
DB_POOL_MAX: "10"
|
||||
REDIS_SOCKET_TIMEOUT: "3"
|
||||
secrets:
|
||||
- database_url
|
||||
- cache_url
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test:
|
||||
[
|
||||
"CMD",
|
||||
"python",
|
||||
"-c",
|
||||
"import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)",
|
||||
]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
start_period: 20s
|
||||
retries: 10
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
pg_data:
|
||||
redis_data:
|
||||
|
||||
secrets:
|
||||
postgres_password:
|
||||
file: ./secrets/postgres_password
|
||||
database_url:
|
||||
file: ./secrets/database_url
|
||||
cache_url:
|
||||
file: ./secrets/cache_url
|
||||
+3
-4
@@ -1,5 +1,4 @@
|
||||
# Доказательства
|
||||
# Evidence
|
||||
|
||||
Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки.
|
||||
|
||||
Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно.
|
||||
Сюда складываются текстовые выводы прогонов (`smoke.txt`, `own.txt`, `persistence.txt`, `explain.txt`).
|
||||
Не коммитьте токены, пароли и полные connection strings.
|
||||
|
||||
Binary file not shown.
@@ -0,0 +1,11 @@
|
||||
chat_id=2f9b61cc-21fd-473b-80c1-0bb95c3814ec messages=10000
|
||||
|
||||
Limit (cost=0.29..5.61 rows=50 width=65) (actual time=0.007..0.014 rows=50 loops=1)
|
||||
Buffers: shared hit=3
|
||||
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..1013.57 rows=9523 width=65) (actual time=0.006..0.010 rows=50 loops=1)
|
||||
Index Cond: (chat_id = '2f9b61cc-21fd-473b-80c1-0bb95c3814ec'::uuid)
|
||||
Buffers: shared hit=3
|
||||
Planning:
|
||||
Buffers: shared hit=34
|
||||
Planning Time: 0.138 ms
|
||||
Execution Time: 0.041 ms
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,37 @@
|
||||
-- Lab2 schema: users, chats, membership, messages.
|
||||
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id UUID PRIMARY KEY,
|
||||
username TEXT NOT NULL,
|
||||
display_name TEXT NOT NULL,
|
||||
password_hash TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE UNIQUE INDEX IF NOT EXISTS users_username_uq ON users (username);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chats (
|
||||
id UUID PRIMARY KEY,
|
||||
title TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chat_members (
|
||||
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 IF NOT EXISTS chat_members_user_id_idx ON chat_members (user_id);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS messages (
|
||||
id UUID PRIMARY KEY,
|
||||
chat_id UUID NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
sender_id UUID NOT NULL REFERENCES users (id),
|
||||
text TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
-- Keyset history: (chat_id, created_at, id) — without full table scan per page.
|
||||
CREATE INDEX IF NOT EXISTS messages_chat_created_id_idx
|
||||
ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1,7 @@
|
||||
fastapi==0.115.6
|
||||
uvicorn==0.32.1
|
||||
pydantic==2.10.3
|
||||
starlette==0.41.3
|
||||
psycopg[binary,pool]==3.2.3
|
||||
redis==5.2.1
|
||||
argon2-cffi==23.1.0
|
||||
@@ -0,0 +1,65 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Seed ≥10k messages and print EXPLAIN (ANALYZE, BUFFERS) for keyset page query."""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import sys
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
# Allow running against a live API + direct DB for EXPLAIN.
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
from app.config import settings # noqa: E402
|
||||
from app.db import Database # noqa: E402
|
||||
from app.models import Chat, Message, User # noqa: E402
|
||||
from app.password import hash_password # noqa: E402
|
||||
from app.timefmt import now_utc # noqa: E402
|
||||
|
||||
|
||||
def main() -> int:
|
||||
count = int(os.environ.get("EXPLAIN_MESSAGES", "10000"))
|
||||
db = Database()
|
||||
db.open()
|
||||
user = User(
|
||||
id=str(uuid.uuid4()),
|
||||
username="explain_" + uuid.uuid4().hex[:10],
|
||||
display_name="Explain",
|
||||
created_at=now_utc(),
|
||||
password_hash=hash_password("Explain-password-12"),
|
||||
)
|
||||
db.add_user(user)
|
||||
chat = Chat(
|
||||
id=str(uuid.uuid4()),
|
||||
title="EXPLAIN chat",
|
||||
member_ids=[user.id],
|
||||
created_at=now_utc(),
|
||||
)
|
||||
db.add_chat(chat)
|
||||
for i in range(count):
|
||||
db.add_message(
|
||||
Message(
|
||||
id=str(uuid.uuid4()),
|
||||
chat_id=chat.id,
|
||||
sender_id=user.id,
|
||||
text="bulk-%d" % i,
|
||||
created_at=now_utc(),
|
||||
)
|
||||
)
|
||||
if (i + 1) % 2000 == 0:
|
||||
print("inserted", i + 1, flush=True)
|
||||
plan = db.explain_messages_page(chat.id, limit=50)
|
||||
out = ROOT / "evidence" / "explain.txt"
|
||||
out.write_text(
|
||||
"chat_id=%s messages=%d\n\n%s\n" % (chat.id, count, plan),
|
||||
encoding="utf-8",
|
||||
)
|
||||
print(plan)
|
||||
print("wrote", out)
|
||||
db.close()
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,13 @@
|
||||
# Creates local synthetic secrets for compose (never commit secrets/).
|
||||
$ErrorActionPreference = "Stop"
|
||||
$root = Split-Path -Parent $PSScriptRoot
|
||||
$secrets = Join-Path $root "secrets"
|
||||
New-Item -ItemType Directory -Force -Path $secrets | Out-Null
|
||||
|
||||
$password = "lab2-pg-pass-" + [guid]::NewGuid().ToString("N").Substring(0, 12)
|
||||
Set-Content -Path (Join-Path $secrets "postgres_password") -Value $password -NoNewline
|
||||
# URL for the API container (service DNS name "postgres" / "redis").
|
||||
$dbUrl = "postgresql://messenger:${password}@postgres:5432/messenger"
|
||||
Set-Content -Path (Join-Path $secrets "database_url") -Value $dbUrl -NoNewline
|
||||
Set-Content -Path (Join-Path $secrets "cache_url") -Value "redis://redis:6379/0" -NoNewline
|
||||
Write-Host "Wrote secrets/postgres_password, secrets/database_url, secrets/cache_url"
|
||||
@@ -0,0 +1,9 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
ROOT="$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)"
|
||||
mkdir -p "$ROOT/secrets"
|
||||
PASSWORD="lab2-pg-pass-$(openssl rand -hex 6)"
|
||||
printf '%s' "$PASSWORD" > "$ROOT/secrets/postgres_password"
|
||||
printf '%s' "postgresql://messenger:${PASSWORD}@postgres:5432/messenger" > "$ROOT/secrets/database_url"
|
||||
printf '%s' "redis://redis:6379/0" > "$ROOT/secrets/cache_url"
|
||||
echo "Wrote secrets/postgres_password, secrets/database_url, secrets/cache_url"
|
||||
@@ -0,0 +1,5 @@
|
||||
@echo off
|
||||
REM Restart API and all state stores without removing volumes (Windows host).
|
||||
cd /d "%~dp0.."
|
||||
docker compose --env-file .env restart
|
||||
exit /b %ERRORLEVEL%
|
||||
@@ -0,0 +1,6 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Restart API and all state stores (postgres, redis) without removing volumes.
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env restart
|
||||
exit 0
|
||||
@@ -0,0 +1,56 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Raw expiry check without OpenAPI schema validation overhead."""
|
||||
import base64
|
||||
import json
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
base = "http://127.0.0.1:8080"
|
||||
username = "u_raw_" + uuid.uuid4().hex[:10]
|
||||
password = "T3st-" + uuid.uuid4().hex
|
||||
body = json.dumps(
|
||||
{"username": username, "display_name": "Raw", "password": password}
|
||||
).encode()
|
||||
req = urllib.request.Request(
|
||||
base + "/api/v1/users",
|
||||
data=body,
|
||||
headers={"Content-Type": "application/json", "Accept": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=30) as r:
|
||||
user = json.loads(r.read())
|
||||
print("user", user["id"])
|
||||
|
||||
cred = base64.b64encode((username + ":" + password).encode()).decode()
|
||||
req = urllib.request.Request(
|
||||
base + "/api/v1/auth/sessions",
|
||||
data=b"",
|
||||
headers={"Authorization": "Basic " + cred, "Accept": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=30) as r:
|
||||
session = json.loads(r.read())
|
||||
print("token_prefix", session["token"][:16], "exp", session["expires_at"])
|
||||
|
||||
req = urllib.request.Request(
|
||||
base + "/api/v1/users/me",
|
||||
headers={"Authorization": "Bearer " + session["token"], "Accept": "application/json"},
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=10) as r:
|
||||
print("me", json.loads(r.read())["id"])
|
||||
|
||||
time.sleep(6)
|
||||
req = urllib.request.Request(
|
||||
base + "/api/v1/users/me",
|
||||
headers={"Authorization": "Bearer " + session["token"], "Accept": "application/json"},
|
||||
)
|
||||
try:
|
||||
urllib.request.urlopen(req, timeout=10)
|
||||
raise SystemExit("FAIL still valid")
|
||||
except urllib.error.HTTPError as exc:
|
||||
print("after wait status", exc.code)
|
||||
if exc.code != 401:
|
||||
raise SystemExit("expected 401")
|
||||
print("PASS: session expired after short TTL")
|
||||
+335
@@ -0,0 +1,335 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Собственные проверки lab2 (оценка 4): auth, гонки, expiry, отказ Redis/DB."""
|
||||
import base64
|
||||
import os
|
||||
import subprocess
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
from urllib.parse import quote
|
||||
|
||||
from client import Client, Failure, arguments, check, run
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
def _password():
|
||||
return "T3st-" + uuid.uuid4().hex
|
||||
|
||||
|
||||
def test_invalid_json(c: Client):
|
||||
resp = c.call(
|
||||
"POST",
|
||||
"/api/v1/users",
|
||||
400,
|
||||
raw=b"{not-json",
|
||||
headers={"Content-Type": "application/json"},
|
||||
schema="Error",
|
||||
)
|
||||
check(resp["json"]["error"]["code"] == "invalid_request", "expected invalid_request for bad JSON")
|
||||
|
||||
|
||||
def test_wrong_password(c: Client):
|
||||
alice = c.user("wp")
|
||||
bad = base64.b64encode(
|
||||
(alice["registration"]["username"] + ":wrong-password-xx").encode()
|
||||
).decode()
|
||||
resp = c.call(
|
||||
"POST",
|
||||
"/api/v1/auth/sessions",
|
||||
401,
|
||||
headers={"Authorization": "Basic " + bad},
|
||||
schema="Error",
|
||||
)
|
||||
check(resp["json"]["error"]["code"] == "unauthorized", "wrong password must be 401")
|
||||
check(
|
||||
resp["headers"].get("WWW-Authenticate", "").lower().startswith("basic"),
|
||||
"WWW-Authenticate Basic required",
|
||||
)
|
||||
|
||||
|
||||
def test_logout(c: Client):
|
||||
alice = c.user("lo")
|
||||
c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=alice)
|
||||
c.call("GET", "/api/v1/users/me", 401, actor=alice, schema="Error")
|
||||
|
||||
|
||||
def test_duplicate_username(c: Client):
|
||||
name = "dup_" + uuid.uuid4().hex[:10]
|
||||
password = _password()
|
||||
body = {"username": name, "display_name": "Один", "password": password}
|
||||
c.call("POST", "/api/v1/users", 201, body=body, schema="User")
|
||||
resp = c.call("POST", "/api/v1/users", 409, body=body, schema="Error")
|
||||
check(resp["json"]["error"]["code"] == "conflict", "expected conflict")
|
||||
|
||||
|
||||
def test_username_race(c: Client):
|
||||
"""Гонка регистрации одинакового username → ровно один 201, остальные 409."""
|
||||
name = "race_" + uuid.uuid4().hex[:10]
|
||||
password = _password()
|
||||
body = {"username": name, "display_name": "Гонка", "password": password}
|
||||
barrier = threading.Barrier(8)
|
||||
results = []
|
||||
|
||||
def worker():
|
||||
local = Client(c.base, timeout=20)
|
||||
barrier.wait()
|
||||
try:
|
||||
resp = local.call("POST", "/api/v1/users", [201, 409], body=body)
|
||||
results.append(resp["status"])
|
||||
except Failure as exc:
|
||||
results.append(str(exc))
|
||||
|
||||
with ThreadPoolExecutor(max_workers=8) as pool:
|
||||
list(pool.map(lambda _: worker(), range(8)))
|
||||
ok = [r for r in results if r == 201]
|
||||
conflicted = [r for r in results if r == 409]
|
||||
check(len(ok) == 1, "expected exactly one successful registration, got %r" % (results,))
|
||||
check(len(conflicted) == 7, "expected seven conflicts, got %r" % (results,))
|
||||
|
||||
|
||||
def test_foreign_chat(c: Client):
|
||||
alice = c.user("own_a")
|
||||
eve = c.user("own_e")
|
||||
chat = c.call(
|
||||
"POST",
|
||||
"/api/v1/chats",
|
||||
201,
|
||||
actor=alice,
|
||||
body={"title": "Секрет", "member_ids": [alice["id"]]},
|
||||
schema="Chat",
|
||||
)["json"]
|
||||
path = "/api/v1/chats/" + chat["id"]
|
||||
c.call("GET", path, 404, actor=eve, schema="Error")
|
||||
c.call("GET", path + "/messages", 404, actor=eve, schema="Error")
|
||||
c.call("POST", path + "/messages", 404, actor=eve, body={"text": "взлом"}, schema="Error")
|
||||
|
||||
|
||||
def test_empty_message(c: Client):
|
||||
alice = c.user("own_empty")
|
||||
chat = c.call(
|
||||
"POST",
|
||||
"/api/v1/chats",
|
||||
201,
|
||||
actor=alice,
|
||||
body={"title": "Тест", "member_ids": [alice["id"]]},
|
||||
schema="Chat",
|
||||
)["json"]
|
||||
for text in ("", " ", "\n\t"):
|
||||
resp = c.call(
|
||||
"POST",
|
||||
"/api/v1/chats/" + chat["id"] + "/messages",
|
||||
400,
|
||||
actor=alice,
|
||||
body={"text": text},
|
||||
schema="Error",
|
||||
)
|
||||
check(resp["json"]["error"]["code"] == "invalid_request", "empty text must be 400")
|
||||
|
||||
|
||||
def test_pagination_pages(c: Client):
|
||||
alice = c.user("page_a")
|
||||
chat = c.call(
|
||||
"POST",
|
||||
"/api/v1/chats",
|
||||
201,
|
||||
actor=alice,
|
||||
body={"title": "Страницы", "member_ids": [alice["id"]]},
|
||||
schema="Chat",
|
||||
)["json"]
|
||||
created = []
|
||||
for i in range(5):
|
||||
created.append(c.message(alice, chat, "msg-%d" % i)["json"])
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
collected = []
|
||||
cursor = None
|
||||
pages = 0
|
||||
while True:
|
||||
q = path + "?limit=2"
|
||||
if cursor:
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=alice, schema="MessagePage")["json"]
|
||||
pages += 1
|
||||
collected.extend(page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
check(pages >= 3, "expected several pages with limit=2 over 5 messages")
|
||||
check(len(collected) == 5, "pagination must return all messages once")
|
||||
from client import timestamp
|
||||
|
||||
expected = sorted(created, key=lambda m: (timestamp(m["created_at"]), uuid.UUID(m["id"]).int))
|
||||
check(collected == expected, "pagination must return keyset order")
|
||||
|
||||
|
||||
def test_session_expiry(c: Client):
|
||||
"""Без schema-валидации клиента: иначе OpenAPI-parse съедает короткий TTL."""
|
||||
import json
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
|
||||
ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
|
||||
if ttl > 5:
|
||||
print("SKIP expiry: set SESSION_TTL_SECONDS<=5 on server and re-run")
|
||||
return
|
||||
username = "ttl_" + uuid.uuid4().hex[:10]
|
||||
password = _password()
|
||||
body = json.dumps(
|
||||
{"username": username, "display_name": "TTL", "password": password}
|
||||
).encode()
|
||||
req = urllib.request.Request(
|
||||
c.base + "/api/v1/users",
|
||||
data=body,
|
||||
headers={"Content-Type": "application/json", "Accept": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=30) as resp:
|
||||
check(resp.status == 201, "register for expiry")
|
||||
cred = base64.b64encode((username + ":" + password).encode()).decode()
|
||||
req = urllib.request.Request(
|
||||
c.base + "/api/v1/auth/sessions",
|
||||
data=b"",
|
||||
headers={"Authorization": "Basic " + cred, "Accept": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=30) as resp:
|
||||
session = json.loads(resp.read())
|
||||
token = session["token"]
|
||||
req = urllib.request.Request(
|
||||
c.base + "/api/v1/users/me",
|
||||
headers={"Authorization": "Bearer " + token, "Accept": "application/json"},
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=10) as resp:
|
||||
check(resp.status == 200, "session must work before expiry")
|
||||
time.sleep(ttl + 1.5)
|
||||
try:
|
||||
urllib.request.urlopen(req, timeout=10)
|
||||
raise Failure("session still valid after TTL")
|
||||
except urllib.error.HTTPError as exc:
|
||||
check(exc.code == 401, "expected 401 after TTL, got %s" % exc.code)
|
||||
print("PASS: session expired after TTL=%d" % ttl)
|
||||
|
||||
|
||||
def _compose(*args: str) -> None:
|
||||
cmd = ["docker", "compose", "--env-file", str(ROOT / ".env"), "-f", str(ROOT / "compose.yaml"), *args]
|
||||
subprocess.check_call(cmd, cwd=str(ROOT), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
|
||||
|
||||
def test_redis_down_recovers(c: Client):
|
||||
"""При недоступности Redis — 503, без «анонимного» доверия; после старта снова ready."""
|
||||
try:
|
||||
_compose("stop", "redis")
|
||||
except (subprocess.CalledProcessError, FileNotFoundError) as exc:
|
||||
print("SKIP redis-down: docker compose unavailable (%s)" % exc)
|
||||
return
|
||||
try:
|
||||
deadline = time.monotonic() + 30
|
||||
saw_503 = False
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
c.call("GET", "/health/ready", 503, schema="Error")
|
||||
saw_503 = True
|
||||
break
|
||||
except Failure:
|
||||
time.sleep(0.5)
|
||||
check(saw_503, "ready must become 503 when redis is down")
|
||||
alice = None
|
||||
# Protected path must not succeed as anonymous / must not 200.
|
||||
try:
|
||||
# Re-login impossible without redis; any bearer must fail closed.
|
||||
c.call(
|
||||
"GET",
|
||||
"/api/v1/users/me",
|
||||
[401, 503],
|
||||
headers={"Authorization": "Bearer deadbeefdeadbeefdeadbeefdeadbeef"},
|
||||
schema="Error",
|
||||
)
|
||||
except Failure as exc:
|
||||
raise Failure("protected endpoint must fail closed when redis down: %s" % exc) from exc
|
||||
finally:
|
||||
_compose("start", "redis")
|
||||
deadline = time.monotonic() + 60
|
||||
while True:
|
||||
try:
|
||||
c.call("GET", "/health/ready", schema="Health")
|
||||
break
|
||||
except Failure:
|
||||
check(time.monotonic() < deadline, "stack did not recover after redis start")
|
||||
time.sleep(0.5)
|
||||
print("PASS: redis down -> 503, then recovery")
|
||||
|
||||
|
||||
def test_concurrency_100(c: Client):
|
||||
alice = c.user("race_a")
|
||||
bob = c.user("race_b")
|
||||
chat = c.call(
|
||||
"POST",
|
||||
"/api/v1/chats",
|
||||
201,
|
||||
actor=alice,
|
||||
body={"title": "Гонка", "member_ids": [alice["id"], bob["id"]]},
|
||||
schema="Chat",
|
||||
)["json"]
|
||||
barrier = threading.Barrier(10)
|
||||
errors = []
|
||||
|
||||
def worker(worker_id: int):
|
||||
local = Client(c.base, timeout=20)
|
||||
actor = alice if worker_id % 2 == 0 else bob
|
||||
barrier.wait()
|
||||
for i in range(10):
|
||||
try:
|
||||
local.message(actor, chat, "race-%d-%d" % (worker_id, i))
|
||||
except Failure as exc:
|
||||
errors.append(str(exc))
|
||||
|
||||
with ThreadPoolExecutor(max_workers=10) as pool:
|
||||
list(pool.map(worker, range(10)))
|
||||
check(not errors, "concurrency errors: " + "; ".join(errors[:3]))
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
collected = []
|
||||
cursor = None
|
||||
while True:
|
||||
q = path + "?limit=100"
|
||||
if cursor:
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=alice, schema="MessagePage")["json"]
|
||||
collected.extend(page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
check(len(collected) == 100, "expected 100 messages, got %d" % len(collected))
|
||||
check(len(set(m["id"] for m in collected)) == 100, "expected 100 unique ids")
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments("Own lab2 tests: auth, races, expiry, redis failure")
|
||||
c = Client(args.base_url, args.ca_file, timeout=20)
|
||||
c.call("GET", "/health/ready", schema="Health")
|
||||
test_invalid_json(c)
|
||||
print("PASS: invalid JSON")
|
||||
test_wrong_password(c)
|
||||
print("PASS: wrong password")
|
||||
test_logout(c)
|
||||
print("PASS: logout")
|
||||
test_duplicate_username(c)
|
||||
print("PASS: duplicate username")
|
||||
test_username_race(c)
|
||||
print("PASS: username registration race")
|
||||
test_foreign_chat(c)
|
||||
print("PASS: foreign chat -> 404")
|
||||
test_empty_message(c)
|
||||
print("PASS: empty message")
|
||||
test_pagination_pages(c)
|
||||
print("PASS: multi-page pagination")
|
||||
test_concurrency_100(c)
|
||||
print("PASS: concurrency 100")
|
||||
test_session_expiry(c)
|
||||
test_redis_down_recovers(c)
|
||||
print("PASS: all own lab2 tests")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
Reference in New Issue
Block a user