Реализация ЛР 2 на 3

This commit is contained in:
2026-11-03 02:07:22 +03:00
parent 65003b6119
commit a3246a08f3
11 changed files with 732 additions and 0 deletions
+26
View File
@@ -0,0 +1,26 @@
FROM python:3.12.7-slim@sha256:60d9996b6a8a3689d36db740b49f4327be3be09a21122bd02fb8895abb38b50d
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
APP_HOST=0.0.0.0 \
APP_PORT=8080
WORKDIR /app
RUN groupadd --system app && \
useradd --system --gid app --create-home app
COPY requirements.txt /app/requirements.txt
RUN pip install --no-cache-dir --timeout 60 -r requirements.txt
COPY --chown=app:app src/ /app/src/
COPY --chown=app:app migrations/ /app/migrations/
USER app
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \
CMD python -c "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2)" || exit 1
CMD ["sh", "-c", "exec uvicorn src.main:app --host \"${APP_HOST}\" --port \"${APP_PORT}\" --timeout-graceful-shutdown 8"]
+44
View File
@@ -0,0 +1,44 @@
name: mtusi-lab2
services:
postgres:
image: postgres:16.6-alpine
restart: unless-stopped
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
api:
build: .
image: mtusi-messenger:lab2
restart: unless-stopped
depends_on:
postgres:
condition: service_healthy
environment:
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DATABASE_URL_FILE: /run/secrets/database_url
secrets:
- database_url
ports:
- "127.0.0.1:8080:8080"
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
volumes:
pgdata:
+63
View File
@@ -0,0 +1,63 @@
-- 001_init: базовая схема лабы 2. Повторный запуск безопасен (IF NOT EXISTS).
CREATE TABLE IF NOT EXISTS users (
id uuid PRIMARY KEY,
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL, -- Argon2id, никогда не отдаётся в API
created_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT users_username_unique UNIQUE (username),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_len CHECK (
char_length(display_name) BETWEEN 1 AND 100 AND btrim(display_name) <> ''
)
);
CREATE TABLE IF NOT EXISTS chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT chats_title_len CHECK (
char_length(title) BETWEEN 1 AND 100 AND btrim(title) <> ''
)
);
-- Порядок списка чатов: (created_at, id)
CREATE INDEX IF NOT EXISTS chats_created_idx ON chats (created_at, id);
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),
position smallint NOT NULL, -- порядок member_ids как в запросе
PRIMARY KEY (chat_id, user_id)
);
-- Список чатов пользователя и проверка членства
CREATE INDEX IF NOT EXISTS chat_members_user_idx ON chat_members (user_id, chat_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 DEFAULT now(),
CONSTRAINT messages_text_len CHECK (
char_length(text) BETWEEN 1 AND 4000 AND btrim(text) <> ''
)
);
-- Keyset-пагинация истории: WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
-- ORDER BY created_at, id LIMIT n -> index scan без сортировки и полного прохода
CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id);
CREATE TABLE IF NOT EXISTS sessions (
token_hash bytea PRIMARY KEY, -- SHA-256 токена; сам токен не хранится
user_id uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT now(),
expires_at timestamptz NOT NULL,
revoked_at timestamptz,
CONSTRAINT sessions_expiry_after_create CHECK (expires_at > created_at)
);
CREATE INDEX IF NOT EXISTS sessions_user_idx ON sessions (user_id);
CREATE INDEX IF NOT EXISTS sessions_expires_idx ON sessions (expires_at);
+15
View File
@@ -0,0 +1,15 @@
annotated-types==0.8.0
anyio==4.15.1
click==8.5.0
fastapi==0.115.2
h11==0.16.0
idna==3.20
pydantic==2.14.1
pydantic-core==2.50.1
starlette==0.40.0
typing-extensions==4.16.0
typing-inspection==0.4.4
uvicorn==0.32.0
asyncpg==0.30.0
argon2-cffi==23.1.0
argon2-cffi-bindings==21.2.0
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
# Перезапуск API и PostgreSQL с сохранением volume (никаких down -v).
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env stop api
docker compose --env-file .env restart postgres
docker compose --env-file .env start api
+80
View File
@@ -0,0 +1,80 @@
import asyncio
import base64
import binascii
import hashlib
import secrets
from typing import Optional, Tuple
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
from fastapi import HTTPException, Request
_hasher = PasswordHasher()
# Хеш-заглушка: для несуществующего пользователя тратим столько же времени, сколько для существующего.
_DUMMY_HASH = _hasher.hash("dummy-password-for-timing")
BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'}
BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
async def hash_password(password: str) -> str:
return await asyncio.to_thread(_hasher.hash, password) # Argon2 грузит CPU, не блокируем event loop
async def verify_password(stored_hash: Optional[str], password: str) -> bool:
try:
return await asyncio.to_thread(_hasher.verify, stored_hash or _DUMMY_HASH, password)
except (VerificationError, InvalidHashError):
return False
def new_token() -> str:
return secrets.token_urlsafe(32) # 256 бит случайности
def token_hash(token: str) -> bytes:
return hashlib.sha256(token.encode()).digest()
def parse_basic(header: Optional[str]) -> Optional[Tuple[str, str]]:
if not header:
return None
scheme, _, value = header.partition(" ")
if scheme.lower() != "basic" or not value:
return None
try:
raw = base64.b64decode(value.strip(), validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError, ValueError):
return None
username, sep, password = raw.partition(":") # двоеточие в пароле допустимо
return (username, password) if sep else None
def parse_bearer(header: Optional[str]) -> Optional[str]:
if not header:
return None
scheme, _, value = header.partition(" ")
value = value.strip()
if scheme.lower() != "bearer" or not value or len(value) > 512:
return None
return value
_SESSION_SQL = """
SELECT u.id, u.username, u.display_name, u.created_at
FROM sessions s JOIN users u ON u.id = s.user_id
WHERE s.token_hash = $1 AND s.revoked_at IS NULL AND s.expires_at > now()
"""
async def current_user(request: Request):
"""Зависимость для всех защищённых endpoint: только Bearer, X-User-Id игнорируется."""
token = parse_bearer(request.headers.get("Authorization"))
if token is None:
raise HTTPException(401, headers=BEARER_CHALLENGE)
digest = token_hash(token)
row = await request.app.state.pool.fetchrow(_SESSION_SQL, digest)
if row is None:
raise HTTPException(401, headers=BEARER_CHALLENGE)
request.state.token_hash = digest
return row
+208
View File
@@ -0,0 +1,208 @@
import base64
import json
import uuid
from datetime import datetime
from typing import List, Optional, Tuple
import asyncpg
from fastapi import APIRouter, Depends, Query, Request
from pydantic import BaseModel, ConfigDict, Field
from .auth import current_user
from .common import iso, make_error_response
router = APIRouter()
class StrictRequest(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
class CreateChatRequest(StrictRequest):
title: str
member_ids: List[str] = Field(min_length=1, max_length=100)
class CreateMessageRequest(StrictRequest):
text: str
def _req_id(request: Request) -> str:
return request.state.request_id
# курсор: непрозрачная строка, привязанная к ресурсу (scope)
def encode_cursor(scope: str, created_at: datetime, row_id: uuid.UUID) -> str:
raw = json.dumps([scope, iso(created_at), str(row_id)]).encode()
return base64.urlsafe_b64encode(raw).decode()
def decode_cursor(cursor: str, scope: str) -> Tuple[datetime, uuid.UUID]:
"""ValueError, если курсор повреждён или выдан для другого ресурса."""
try:
sc, ts, rid = json.loads(base64.urlsafe_b64decode(cursor.encode()))
if sc != scope:
raise ValueError("scope mismatch")
return datetime.fromisoformat(ts), uuid.UUID(rid)
except Exception as exc:
raise ValueError("invalid cursor") from exc
def _bad_text(value: str) -> bool:
return not value.strip() or "\x00" in value # NUL нельзя хранить в PostgreSQL text
_CHAT_COLUMNS = (
"c.id, c.title, c.created_at, "
"array(SELECT m2.user_id FROM chat_members m2 WHERE m2.chat_id = c.id ORDER BY m2.position) AS member_ids"
)
def chat_dict(row) -> dict:
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(m) for m in row["member_ids"]],
"created_at": iso(row["created_at"]),
}
def message_dict(row) -> dict:
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": iso(row["created_at"]),
}
def _check_limit(limit: int) -> bool:
return 1 <= limit <= 100
# чаты
@router.post("/chats", status_code=201)
async def create_chat(req: CreateChatRequest, request: Request, user=Depends(current_user)):
req_id = _req_id(request)
if not (1 <= len(req.title) <= 100) or _bad_text(req.title):
return make_error_response(400, "invalid_request", "Invalid title", req_id)
try:
members = [uuid.UUID(m) for m in req.member_ids]
except ValueError:
return make_error_response(400, "invalid_request", "Invalid member id", req_id)
if len(members) != len(set(members)):
return make_error_response(400, "invalid_request", "Duplicate members found", req_id)
if user["id"] not in members:
return make_error_response(400, "invalid_request", "Caller must be in member_ids", req_id)
chat_id = uuid.uuid4()
try:
async with request.app.state.pool.acquire() as conn:
# Чат и все участники - одна транзакция: неизвестный участник откатывает всё.
async with conn.transaction():
created_at = await conn.fetchval(
"INSERT INTO chats (id, title, created_at) VALUES ($1, $2, clock_timestamp()) RETURNING created_at",
chat_id, req.title,
)
await conn.execute(
"INSERT INTO chat_members (chat_id, user_id, position) "
"SELECT $1, t.u, (t.p - 1)::smallint FROM unnest($2::uuid[]) WITH ORDINALITY AS t(u, p)",
chat_id, members,
)
except asyncpg.ForeignKeyViolationError:
return make_error_response(400, "invalid_request", "Unknown member", req_id)
return {"id": str(chat_id), "title": req.title, "member_ids": [str(m) for m in members],
"created_at": iso(created_at)}
@router.get("/chats")
async def list_chats(request: Request, limit: int = 50,
cursor: Optional[str] = Query(default=None, min_length=1, max_length=512),
user=Depends(current_user)):
req_id = _req_id(request)
if not _check_limit(limit):
return make_error_response(400, "invalid_request", "Limit must be between 1 and 100", req_id)
scope = "chats:" + str(user["id"])
base = (f"SELECT {_CHAT_COLUMNS} FROM chats c "
"JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1 ")
if cursor is None:
rows = await request.app.state.pool.fetch(
base + "ORDER BY c.created_at, c.id LIMIT $2", user["id"], limit + 1)
else:
try:
ts, rid = decode_cursor(cursor, scope)
except ValueError:
return make_error_response(400, "invalid_request", "Invalid cursor", req_id)
rows = await request.app.state.pool.fetch(
base + "WHERE (c.created_at, c.id) > ($2::timestamptz, $3::uuid) "
"ORDER BY c.created_at, c.id LIMIT $4",
user["id"], ts, rid, limit + 1)
items = rows[:limit]
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if len(rows) > limit else None
return {"items": [chat_dict(r) for r in items], "next_cursor": next_cursor}
@router.get("/chats/{chat_id}")
async def get_chat(chat_id: uuid.UUID, request: Request, user=Depends(current_user)):
row = await request.app.state.pool.fetchrow(
f"SELECT {_CHAT_COLUMNS} FROM chats c WHERE c.id = $1 "
"AND EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = $2)",
chat_id, user["id"],
)
if row is None:
return make_error_response(404, "not_found", "Chat not found", _req_id(request))
return chat_dict(row)
# сообщения
@router.post("/chats/{chat_id}/messages", status_code=201)
async def send_message(chat_id: uuid.UUID, req: CreateMessageRequest, request: Request,
user=Depends(current_user)):
req_id = _req_id(request)
if _bad_text(req.text):
return make_error_response(400, "invalid_request", "Empty message text", req_id)
if len(req.text) > 4000:
return make_error_response(400, "invalid_request", "Message text exceeds 4000 characters", req_id)
# Проверка членства и вставка - один атомарный оператор.
row = await request.app.state.pool.fetchrow(
"INSERT INTO messages (id, chat_id, sender_id, text, created_at) "
"SELECT $1, $2, $3, $4, clock_timestamp() "
"WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3) "
"RETURNING id, chat_id, sender_id, text, created_at",
uuid.uuid4(), chat_id, user["id"], req.text,
)
if row is None:
return make_error_response(404, "not_found", "Chat not found", req_id)
return message_dict(row)
@router.get("/chats/{chat_id}/messages")
async def get_messages(chat_id: uuid.UUID, request: Request, limit: int = 50,
cursor: Optional[str] = Query(default=None, min_length=1, max_length=512),
user=Depends(current_user)):
req_id = _req_id(request)
if not _check_limit(limit):
return make_error_response(400, "invalid_request", "Limit must be between 1 and 100", req_id)
pool = request.app.state.pool
is_member = await pool.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2", chat_id, user["id"])
if not is_member:
return make_error_response(404, "not_found", "Chat not found", req_id)
scope = "msgs:" + str(chat_id)
base = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1 "
if cursor is None:
rows = await pool.fetch(base + "ORDER BY created_at, id LIMIT $2", chat_id, limit + 1)
else:
try:
ts, rid = decode_cursor(cursor, scope)
except ValueError:
return make_error_response(400, "invalid_request", "Invalid cursor", req_id)
rows = await pool.fetch(
base + "AND (created_at, id) > ($2::timestamptz, $3::uuid) ORDER BY created_at, id LIMIT $4",
chat_id, ts, rid, limit + 1)
items = rows[:limit]
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if len(rows) > limit else None
return {"items": [message_dict(r) for r in items], "next_cursor": next_cursor}
+29
View File
@@ -0,0 +1,29 @@
from datetime import datetime, timezone
from typing import Optional
from fastapi.responses import JSONResponse
def iso(dt: datetime) -> str:
"""RFC 3339 UTC с Z; микросекунды нужны, чтобы курсор был точным."""
return dt.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
def make_error_response(status_code: int, code: str, message: str, req_id: str, headers: Optional[dict] = None):
h = {"X-Request-Id": req_id}
if headers:
h.update(headers)
return JSONResponse(
status_code=status_code,
content={"error": {"code": code, "message": message, "request_id": req_id}},
headers=h,
)
def user_dict(row) -> dict:
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": iso(row["created_at"]),
}
+21
View File
@@ -0,0 +1,21 @@
import os
from pathlib import Path
def _read_secret(file_var: str, direct_var: str) -> str:
"""Секрет из файла (DATABASE_URL_FILE), с запасным вариантом из переменной окружения."""
path = os.environ.get(file_var)
if path:
return Path(path).read_text().strip()
return os.environ.get(direct_var, "")
DATABASE_URL = _read_secret("DATABASE_URL_FILE", "DATABASE_URL")
SESSION_TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
DB_POOL_MIN = int(os.environ.get("DB_POOL_MIN", "2"))
DB_POOL_MAX = int(os.environ.get("DB_POOL_MAX", "10"))
DB_CONNECT_TIMEOUT = float(os.environ.get("DB_CONNECT_TIMEOUT", "5"))
DB_COMMAND_TIMEOUT = float(os.environ.get("DB_COMMAND_TIMEOUT", "5"))
MIGRATIONS_DIR = Path(os.environ.get("MIGRATIONS_DIR", Path(__file__).resolve().parent.parent / "migrations"))
+56
View File
@@ -0,0 +1,56 @@
import asyncio
import logging
import asyncpg
from . import config
logger = logging.getLogger("messenger")
# Произвольный константный ключ: один экземпляр выполняет миграции, остальные ждут.
MIGRATION_LOCK_KEY = 727_001
async def create_pool() -> asyncpg.Pool:
# Пул ограничен по размеру; у соединений и команд есть таймауты.
return await asyncpg.create_pool(
dsn=config.DATABASE_URL,
min_size=config.DB_POOL_MIN,
max_size=config.DB_POOL_MAX,
timeout=config.DB_CONNECT_TIMEOUT,
command_timeout=config.DB_COMMAND_TIMEOUT,
)
async def create_pool_with_retry(attempts: int = 30, delay: float = 1.0) -> asyncpg.Pool:
# БД в compose может подняться позже API.
for attempt in range(1, attempts + 1):
try:
return await create_pool()
except (OSError, asyncpg.PostgresError, asyncio.TimeoutError) as exc:
logger.warning("DB not ready (%d/%d): %s", attempt, attempts, type(exc).__name__)
await asyncio.sleep(delay)
raise RuntimeError("database is unavailable")
async def run_migrations(pool: asyncpg.Pool) -> None:
# Применяет migrations/*.sql по порядку имён, каждую один раз.
files = sorted(config.MIGRATIONS_DIR.glob("*.sql"))
async with pool.acquire() as conn:
await conn.execute("SELECT pg_advisory_lock($1)", MIGRATION_LOCK_KEY)
try:
await conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
" version text PRIMARY KEY,"
" applied_at timestamptz NOT NULL DEFAULT now())"
)
applied = {r["version"] for r in await conn.fetch("SELECT version FROM schema_migrations")}
for path in files:
if path.name in applied:
continue
async with conn.transaction():
await conn.execute(path.read_text())
await conn.execute("INSERT INTO schema_migrations (version) VALUES ($1)", path.name)
logger.info("Applied migration %s", path.name)
finally:
await conn.execute("SELECT pg_advisory_unlock($1)", MIGRATION_LOCK_KEY)
+183
View File
@@ -0,0 +1,183 @@
import asyncio
import logging
import re
import sys
import uuid
from contextlib import asynccontextmanager
import asyncpg
from fastapi import Depends, FastAPI, Request, Response
from fastapi.exceptions import RequestValidationError
from pydantic import BaseModel, ConfigDict
from starlette.exceptions import HTTPException
from . import config
from .auth import (BASIC_CHALLENGE, current_user, hash_password, new_token,
parse_basic, token_hash, verify_password)
from .chats import router as chats_router
from .common import iso, make_error_response, user_dict
from .db import create_pool_with_retry, run_migrations
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] [req_id=%(request_id)s] %(message)s",
handlers=[logging.StreamHandler(sys.stdout)],
)
class RequestIdFilter(logging.Filter):
def filter(self, record):
if not hasattr(record, "request_id"):
record.request_id = "-"
return True
logger = logging.getLogger("messenger")
logger.addFilter(RequestIdFilter())
is_shutting_down = False
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}")
@asynccontextmanager
async def lifespan(app: FastAPI):
app.state.pool = await create_pool_with_retry()
await run_migrations(app.state.pool)
yield
global is_shutting_down
is_shutting_down = True
await app.state.pool.close()
logger.info("Application shutdown complete")
app = FastAPI(title="MTUSI Messenger - Lab 2", lifespan=lifespan)
app.include_router(chats_router, prefix="/api/v1")
@app.middleware("http")
async def middleware_pipeline(request: Request, call_next):
req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
request.state.request_id = req_id
if is_shutting_down and request.url.path != "/health/live":
return make_error_response(503, "unavailable", "Server is shutting down", req_id)
logger.info(f"Incoming request {request.method} {request.url.path}", extra={"request_id": req_id})
response: Response = await call_next(request)
response.headers["X-Request-Id"] = req_id
logger.info(f"Completed {request.method} {request.url.path} with status {response.status_code}",
extra={"request_id": req_id})
return response
def _req_id(request: Request) -> str:
return getattr(request.state, "request_id", str(uuid.uuid4()))
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
return make_error_response(400, "invalid_request", "Validation error", _req_id(request))
@app.exception_handler(HTTPException)
async def http_exception_handler(request: Request, exc: HTTPException):
code = {
400: "invalid_request", 401: "unauthorized", 404: "not_found", 409: "conflict",
413: "payload_too_large", 415: "unsupported_media_type", 429: "rate_limited", 503: "unavailable",
}.get(exc.status_code, "internal_error" if exc.status_code >= 500 else "invalid_request")
return make_error_response(exc.status_code, code, "Request failed", _req_id(request), exc.headers)
async def dependency_unavailable_handler(request: Request, exc: Exception):
"""БД недоступна или не ответила в срок: ограниченная 503, без деталей и без доверия анониму."""
logger.error("Dependency failure: %s", type(exc).__name__, extra={"request_id": _req_id(request)})
return make_error_response(503, "unavailable", "Service temporarily unavailable", _req_id(request))
for _exc in (asyncpg.PostgresError, asyncpg.InterfaceError, ConnectionError, asyncio.TimeoutError):
app.add_exception_handler(_exc, dependency_unavailable_handler)
@app.exception_handler(Exception)
async def generic_exception_handler(request: Request, exc: Exception):
logger.error("Unhandled exception: %s", type(exc).__name__, extra={"request_id": _req_id(request)})
return make_error_response(500, "internal_error", "Internal server error", _req_id(request))
class StrictRequest(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
class CreateUserRequest(StrictRequest):
username: str
display_name: str
password: str
@app.get("/health/live")
async def health_live():
return {"status": "ok"}
@app.get("/health/ready")
async def health_ready(request: Request):
# Критичная зависимость для готовности - PostgreSQL.
await request.app.state.pool.fetchval("SELECT 1", timeout=2)
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
async def register_user(req: CreateUserRequest, request: Request):
req_id = _req_id(request)
if not USERNAME_RE.fullmatch(req.username):
return make_error_response(400, "invalid_request", "Invalid username format", req_id)
if not (1 <= len(req.display_name) <= 100) or not req.display_name.strip() or "\x00" in req.display_name:
return make_error_response(400, "invalid_request", "Invalid display_name", req_id)
if not (12 <= len(req.password) <= 128):
return make_error_response(400, "invalid_request", "Invalid password length", req_id)
pw_hash = await hash_password(req.password)
try:
row = await request.app.state.pool.fetchrow(
"INSERT INTO users (id, username, display_name, password_hash, created_at) "
"VALUES ($1, $2, $3, $4, clock_timestamp()) "
"RETURNING id, username, display_name, created_at",
uuid.uuid4(), req.username, req.display_name, pw_hash,
)
except asyncpg.UniqueViolationError: # гонку одинаковых username решает UNIQUE, а не SELECT
return make_error_response(409, "conflict", "Username already exists", req_id)
return user_dict(row)
@app.get("/api/v1/users/me")
async def get_current_user(user=Depends(current_user)):
return user_dict(user)
@app.post("/api/v1/auth/sessions", status_code=201)
async def create_session(request: Request):
req_id = _req_id(request)
creds = parse_basic(request.headers.get("Authorization"))
if creds is None:
return make_error_response(401, "unauthorized", "Unauthorized", req_id, BASIC_CHALLENGE)
username, password = creds
pool = request.app.state.pool
row = await pool.fetchrow(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = $1", username
)
ok = await verify_password(row["password_hash"] if row else None, password)
if row is None or not ok:
return make_error_response(401, "unauthorized", "Unauthorized", req_id, BASIC_CHALLENGE)
token = new_token()
expires_at = await pool.fetchval(
"INSERT INTO sessions (token_hash, user_id, created_at, expires_at) "
"VALUES ($1, $2, now(), now() + make_interval(secs => $3)) RETURNING expires_at",
token_hash(token), row["id"], float(config.SESSION_TTL_SECONDS),
)
return {"token": token, "token_type": "Bearer", "expires_at": iso(expires_at), "user": user_dict(row)}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def logout(request: Request, user=Depends(current_user)):
await request.app.state.pool.execute(
"UPDATE sessions SET revoked_at = now() WHERE token_hash = $1", request.state.token_hash
)
return Response(status_code=204)