Files
mtusi2026lab3/src/api.py
T

395 lines
15 KiB
Python

"""Routes, authentication and request validation for lab 2."""
from __future__ import annotations
import base64
import binascii
import hashlib
import json
import re
import uuid
from dataclasses import dataclass
from typing import Annotated, Any, cast
from fastapi import APIRouter, Depends, Request, Response
from psycopg_pool import AsyncConnectionPool
from pydantic import ValidationError
from starlette.concurrency import run_in_threadpool
from . import sessions as session_service
from . import store
from .config import DEFAULT_PAGE_SIZE, MAX_JSON_BYTES, MAX_PAGE_SIZE, IDEMPOTENCY_KEY_PATTERN
from .db import ping
from .errors import BASIC_CHALLENGE, BEARER_CHALLENGE, ApiProblem
from .models import CreateChat, CreateMessage, CreateUser, StrictModel
from .pagination import build_page, decode_cursor, format_timestamp
from .security import hash_password, verify_password, verify_password_unknown_user
router = APIRouter()
USERNAME_PATTERN = re.compile(r"^[a-z0-9_]{3,32}$")
@dataclass(frozen=True)
class Principal:
"""The authenticated identity behind a Bearer token."""
user_id: uuid.UUID
user: dict[str, Any]
def get_pool(request: Request) -> AsyncConnectionPool:
return cast(AsyncConnectionPool, request.app.state.pool)
def get_cache(request: Request) -> session_service.SessionCache:
return cast(session_service.SessionCache, request.app.state.cache)
async def drain_body(request: Request) -> None:
"""Consume an unwanted request body without retaining it in memory."""
async for _chunk in request.stream():
pass
def declared_body_size(request: Request) -> int | None:
value = request.headers.get("Content-Length")
if value is None:
return None
try:
size = int(value)
except ValueError:
raise ApiProblem(400, "invalid_request", "Content-Length is invalid") from None
if size < 0:
raise ApiProblem(400, "invalid_request", "Content-Length is invalid")
return size
async def read_limited_body(request: Request) -> bytes:
chunks: list[bytes] = []
size = 0
too_large = False
async for chunk in request.stream():
size += len(chunk)
if size <= MAX_JSON_BYTES:
chunks.append(chunk)
else:
too_large = True
if too_large:
raise ApiProblem(413, "payload_too_large", "Request body is too large")
return b"".join(chunks)
async def parse_body(request: Request, model: type[StrictModel]) -> Any:
content_length = declared_body_size(request)
if content_length is not None and content_length > MAX_JSON_BYTES:
await drain_body(request)
raise ApiProblem(413, "payload_too_large", "Request body is too large")
content_type = request.headers.get("Content-Type", "").split(";", 1)[0].strip()
if content_type.lower() != "application/json":
await drain_body(request)
raise ApiProblem(
415, "unsupported_media_type", "Content-Type must be application/json"
)
body = await read_limited_body(request)
try:
decoded = json.loads(body.decode("utf-8"))
except (json.JSONDecodeError, UnicodeDecodeError):
raise ApiProblem(
400, "invalid_request", "Request body is not valid JSON"
) from None
try:
return model.model_validate(decoded)
except ValidationError:
raise ApiProblem(400, "invalid_request", "Request fields are invalid") from None
def ensure_no_query(request: Request) -> None:
if request.url.query:
raise ApiProblem(400, "invalid_request", "Query parameters are not supported")
def parse_pagination_request(request: Request) -> tuple[int, str | None]:
"""Read limit/cursor only; unknown or repeated parameters are a 400."""
parameters = request.query_params
keys = [key for key, _ in parameters.multi_items()]
if set(keys) - {"limit", "cursor"} or any(
keys.count(key) != 1 for key in set(keys)
):
raise ApiProblem(400, "invalid_request", "Query parameters are invalid")
limit_value = parameters.get("limit", str(DEFAULT_PAGE_SIZE))
try:
limit = int(limit_value)
except (TypeError, ValueError):
raise ApiProblem(400, "invalid_request", "limit is invalid") from None
if not 1 <= limit <= MAX_PAGE_SIZE:
raise ApiProblem(400, "invalid_request", "limit is invalid")
cursor = parameters.get("cursor")
if cursor == "":
raise ApiProblem(400, "invalid_request", "cursor is invalid")
return limit, cursor
def require_chat_id(chat_id: str) -> uuid.UUID:
try:
return uuid.UUID(chat_id)
except (ValueError, AttributeError):
raise ApiProblem(400, "invalid_request", "chat_id must be a UUID") from None
def unauthorized(message: str, challenge: str) -> ApiProblem:
return ApiProblem(401, "unauthorized", message, {"WWW-Authenticate": challenge})
def bearer_token(request: Request) -> str:
"""Only Bearer is accepted; Basic here is a 401, not a fallback login."""
header = request.headers.get("Authorization")
if header is None:
raise unauthorized("Bearer session token is required", BEARER_CHALLENGE)
scheme, _, value = header.partition(" ")
if scheme.strip().lower() != "bearer" or not value.strip():
raise unauthorized("Bearer session token is required", BEARER_CHALLENGE)
return value.strip()
def basic_credentials(request: Request) -> tuple[str, str]:
"""Decode Basic credentials; it is an encoding, never a trusted identity."""
header = request.headers.get("Authorization")
if header is None:
raise unauthorized("Basic credentials are required", BASIC_CHALLENGE)
scheme, _, value = header.partition(" ")
if scheme.strip().lower() != "basic" or not value.strip():
raise unauthorized("Basic credentials are required", BASIC_CHALLENGE)
try:
raw = base64.b64decode(value.strip(), validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError, ValueError):
raise unauthorized("Basic credentials are invalid", BASIC_CHALLENGE) from None
username, separator, password = raw.partition(":")
if not separator or not username or not password:
raise unauthorized("Basic credentials are invalid", BASIC_CHALLENGE)
if USERNAME_PATTERN.fullmatch(username) is None:
# Unknown or malformed usernames must not be distinguished from a bad password.
raise unauthorized("Invalid username or password", BASIC_CHALLENGE)
return username, password
async def current_principal(request: Request) -> Principal:
token = bearer_token(request)
user_id, user = await session_service.resolve_session(
get_pool(request), get_cache(request), token
)
return Principal(user_id=user_id, user=user)
Actor = Annotated[Principal, Depends(current_principal)]
# --------------------------------------------------------------------------- #
# Health
# --------------------------------------------------------------------------- #
@router.get("/health/live")
async def liveness(request: Request) -> dict[str, str]:
ensure_no_query(request)
return {"status": "ok"}
@router.get("/health/ready")
async def readiness(request: Request) -> dict[str, str]:
ensure_no_query(request)
try:
await ping(get_pool(request))
except Exception as exc: # noqa: BLE001 - any DB failure means not ready
request.app.state.logger.warning(
"readiness_database_failed error=%s", type(exc).__name__
)
raise ApiProblem(503, "unavailable", "Database is unavailable") from None
return {"status": "ok"}
# --------------------------------------------------------------------------- #
# Users and sessions
# --------------------------------------------------------------------------- #
@router.post("/api/v1/users", status_code=201)
async def register_user(request: Request) -> dict[str, Any]:
ensure_no_query(request)
body = await parse_body(request, CreateUser)
assert isinstance(body, CreateUser)
password_hash = await run_in_threadpool(hash_password, body.password)
async with get_pool(request).connection() as connection:
async with connection.cursor() as cursor:
return await store.create_user(
cursor,
username=body.username,
display_name=body.display_name,
password_hash=password_hash,
)
@router.post("/api/v1/auth/sessions", status_code=201)
async def create_session(request: Request) -> dict[str, Any]:
ensure_no_query(request)
await drain_body(request)
username, password = basic_credentials(request)
pool = get_pool(request)
async with pool.connection() as connection:
async with connection.cursor() as cursor:
row = await store.user_credentials(cursor, username)
if row is None:
await run_in_threadpool(verify_password_unknown_user, password)
raise unauthorized("Invalid username or password", BASIC_CHALLENGE)
if not await run_in_threadpool(
verify_password, password, row["password_hash"]
):
raise unauthorized("Invalid username or password", BASIC_CHALLENGE)
token, expires_at = await session_service.create_session(
pool,
get_cache(request),
user_id=row["id"],
ttl_seconds=request.app.state.settings.session_ttl_seconds,
)
return {
"token": token,
"token_type": "Bearer",
"expires_at": format_timestamp(expires_at),
"user": store.user_json(row),
}
@router.delete("/api/v1/auth/sessions/current", status_code=204)
async def delete_current_session(request: Request) -> Response:
ensure_no_query(request)
token = bearer_token(request)
await session_service.revoke_session(get_pool(request), get_cache(request), token)
return Response(status_code=204)
@router.get("/api/v1/users/me")
async def current_user(request: Request, actor: Actor) -> dict[str, Any]:
ensure_no_query(request)
return actor.user
# --------------------------------------------------------------------------- #
# Chats and messages
# --------------------------------------------------------------------------- #
@router.post("/api/v1/chats", status_code=201)
async def create_chat(request: Request, actor: Actor) -> dict[str, Any]:
ensure_no_query(request)
body = await parse_body(request, CreateChat)
assert isinstance(body, CreateChat)
members = [uuid.UUID(member) for member in body.member_ids]
async with get_pool(request).connection() as connection:
async with connection.cursor() as cursor:
return await store.create_chat(
cursor, actor_id=actor.user_id, title=body.title, member_ids=members
)
@router.get("/api/v1/chats")
async def list_chats(request: Request, actor: Actor) -> dict[str, Any]:
limit, cursor = parse_pagination_request(request)
resource = "chats:" + str(actor.user_id)
after = decode_cursor(cursor, resource) if cursor is not None else None
async with get_pool(request).connection() as connection:
async with connection.cursor() as cursor_handle:
rows = await store.chat_page(
cursor_handle, actor_id=actor.user_id, limit=limit, after=after
)
return build_page(rows, resource, limit)
@router.get("/api/v1/chats/{chat_id}")
async def get_chat(request: Request, chat_id: str, actor: Actor) -> dict[str, Any]:
ensure_no_query(request)
normalized = require_chat_id(chat_id)
async with get_pool(request).connection() as connection:
async with connection.cursor() as cursor:
return await store.accessible_chat(
cursor, actor_id=actor.user_id, chat_id=normalized
)
@router.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def create_message(
request: Request, chat_id: str, actor: Actor
) -> dict[str, Any]:
normalized = require_chat_id(chat_id)
ensure_no_query(request)
body = await parse_body(request, CreateMessage)
assert isinstance(body, CreateMessage)
pool = get_pool(request)
request_sha256 = hashlib.sha256(
json.dumps(body.model_dump(), sort_keys=True).encode("utf-8")
).hexdigest()
async with pool.connection() as connection:
async with connection.cursor() as cursor:
# Check membership first so non-members get 404, not 400.
await store.require_membership(
cursor, actor_id=actor.user_id, chat_id=normalized
)
key = request.headers.get("Idempotency-Key", "").strip()
if not key or not IDEMPOTENCY_KEY_PATTERN.fullmatch(key):
raise ApiProblem(
400, "invalid_request", "Idempotency-Key must match "
"^[A-Za-z0-9._:-]{1,128}$"
)
existing = await store.get_idempotency_key(
cursor, actor_id=actor.user_id, chat_id=normalized, key=key
)
if existing is not None:
if existing["request_sha256"] != request_sha256:
raise ApiProblem(409, "conflict", "Idempotency-Key was already used")
# Replay: return the original message.
original = await store.message_by_id(cursor, existing["message_id"])
if original is not None:
return original
inserted = await store.insert_idempotency_key(
cursor,
actor_id=actor.user_id,
key=key,
chat_id=normalized,
request_sha256=request_sha256,
)
if not inserted:
# INSERT .. ON CONFLICT keeps this transaction usable. PostgreSQL
# waited for the winning transaction, so its message is committed
# and can be returned as the exact replay result.
existing = await store.get_idempotency_key(
cursor, actor_id=actor.user_id, chat_id=normalized, key=key
)
if existing is not None:
if existing["request_sha256"] != request_sha256:
raise ApiProblem(409, "conflict", "Idempotency-Key was already used")
original = await store.message_by_id(cursor, existing["message_id"])
if original is not None:
return original
raise ApiProblem(409, "conflict", "Idempotency-Key is still being stored")
return await store.create_message(
cursor,
actor_id=actor.user_id,
chat_id=normalized,
text=body.text,
request_sha256=request_sha256,
key=key,
)
@router.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(
request: Request, chat_id: str, actor: Actor
) -> dict[str, Any]:
normalized = require_chat_id(chat_id)
limit, cursor = parse_pagination_request(request)
resource = "messages:" + str(normalized)
after = decode_cursor(cursor, resource) if cursor is not None else None
async with get_pool(request).connection() as connection:
async with connection.cursor() as cursor_handle:
await store.require_membership(
cursor_handle, actor_id=actor.user_id, chat_id=normalized
)
rows = await store.message_page(
cursor_handle, chat_id=normalized, limit=limit, after=after
)
return build_page(rows, resource, limit)