Author SHA1 Message Date
daniil_sobolev 873eff9a3f report 2026-10-29 01:32:09 +03:00
daniil_sobolev 3c5af42f24 Lab2: PostgreSQL, Bearer sessions and Redis for grade 4 2026-10-29 01:25:40 +03:00
35 changed files with 2127 additions and 26 deletions
+9 -4
View File
@@ -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
View File
@@ -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"]
+14 -2
View File
@@ -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
+91 -16
View File
@@ -1,37 +1,112 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Соболев Даниил Романович, БПИ2302
- Целевая оценка; выбранный трек 5, если нужен: 4
- Commit/PR: 3c5af42f24
- Использованные источники, библиотеки и помощь ИИ: 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.
+1
View File
@@ -0,0 +1 @@
"""Messenger API lab2: PostgreSQL + Bearer sessions + Redis."""
+169
View File
@@ -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
View File
@@ -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
+35
View File
@@ -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()
+27
View File
@@ -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
+376
View File
@@ -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)
+54
View File
@@ -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
View File
@@ -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()
+58
View File
@@ -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)
+18
View File
@@ -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
+28
View File
@@ -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
View File
@@ -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}
+93
View File
@@ -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)
+20
View File
@@ -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)
+102
View File
@@ -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
+95
View File
@@ -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
View File
@@ -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.
+11
View File
@@ -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
BIN
View File
Binary file not shown.
Binary file not shown.
Binary file not shown.
+37
View File
@@ -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);
+7
View File
@@ -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
+65
View File
@@ -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())
+13
View File
@@ -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"
+9
View File
@@ -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"
+5
View File
@@ -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%
+6
View File
@@ -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
+56
View File
@@ -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
View File
@@ -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)