Files
mtusi2026lab2/app/main.py
T

494 lines
21 KiB
Python

"""Lab 2: stateless HTTP API, PostgreSQL source of truth, durable Redis sessions."""
from __future__ import annotations
import base64
import binascii
import hashlib
import json
import logging
import os
import re
import secrets
import uuid
from contextlib import asynccontextmanager
from datetime import datetime, timedelta, timezone
from typing import Any
import psycopg
import redis
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
from fastapi import FastAPI, Query, Request
from fastapi.concurrency import run_in_threadpool
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse, Response
from psycopg.errors import UniqueViolation
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool, PoolTimeout
from pydantic import BaseModel, ConfigDict, Field, field_validator
logging.basicConfig(level=os.environ.get("LOG_LEVEL", "INFO"), format="%(asctime)s %(levelname)s %(name)s %(message)s")
logger = logging.getLogger("messenger")
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}\Z")
ph = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1) # Argon2id; bounded 19 MiB/KDF.
# Dummy KDF verification on unknown users reduces username-enumeration timing leakage.
DUMMY_HASH = ph.hash("lab2-dummy-password-not-for-login")
def iso(dt: datetime) -> str:
return dt.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
class APIError(Exception):
def __init__(self, status: int, code: str, message: str):
super().__init__(message)
self.status, self.code, self.message = status, code, message
class StrictModel(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
class CreateUser(StrictModel):
username: str
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
@field_validator("username")
@classmethod
def check_username(cls, v: str) -> str:
if not USERNAME_RE.fullmatch(v):
raise ValueError("invalid username")
return v
@field_validator("display_name", "password")
@classmethod
def non_blank(cls, v: str) -> str:
if not v.strip():
raise ValueError("must not be blank")
try:
v.encode("utf-8")
except UnicodeEncodeError as exc:
raise ValueError("must be valid UTF-8") from exc
return v
class CreateChat(StrictModel):
title: str = Field(min_length=1, max_length=100)
member_ids: list[str] = Field(min_length=1, max_length=100)
@field_validator("title")
@classmethod
def non_blank(cls, v: str) -> str:
if not v.strip():
raise ValueError("blank title")
try:
v.encode("utf-8")
except UnicodeEncodeError as exc:
raise ValueError("must be valid UTF-8") from exc
return v
@field_validator("member_ids")
@classmethod
def unique(cls, v: list[str]) -> list[str]:
if len(v) != len(set(v)):
raise ValueError("duplicate members")
return v
class CreateMessage(StrictModel):
text: str = Field(min_length=1, max_length=4000)
@field_validator("text")
@classmethod
def non_blank(cls, v: str) -> str:
if not v.strip():
raise ValueError("blank message")
try:
v.encode("utf-8")
except UnicodeEncodeError as exc:
raise ValueError("must be valid UTF-8") from exc
return v
@asynccontextmanager
async def lifespan(app: FastAPI):
url = os.environ.get("DATABASE_URL")
if not url:
raise RuntimeError("DATABASE_URL must be provided (do not commit credentials)")
pool = ConnectionPool(url, min_size=1, max_size=int(os.environ.get("DB_POOL_MAX", "8")),
timeout=3, max_lifetime=1800,
kwargs={"row_factory": dict_row, "connect_timeout": 5, "options": "-c statement_timeout=5000"}, open=False)
pool.open(wait=False)
app.state.pool = pool
app.state.sessions = redis.Redis.from_url(os.environ.get("REDIS_URL", "redis://redis:6379/0"),
socket_connect_timeout=2, socket_timeout=2,
health_check_interval=10, decode_responses=True)
ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
if ttl < 1:
raise RuntimeError("SESSION_TTL_SECONDS must be >= 1")
app.state.session_ttl = ttl
try:
yield
finally:
app.state.sessions.close()
pool.close()
app = FastAPI(title="MTUCI Messenger Lab 2", docs_url=None, redoc_url=None, openapi_url=None, lifespan=lifespan)
def reqid(request: Request) -> str:
return getattr(request.state, "request_id", "unknown")
def error_response(request: Request, status: int, code: str, message: str) -> JSONResponse:
result = JSONResponse(status_code=status, content={"error": {"code": code, "message": message, "request_id": reqid(request)}})
if status == 401:
scheme = 'Basic' if request.url.path == "/api/v1/auth/sessions" else 'Bearer'
result.headers["WWW-Authenticate"] = (f'Basic realm="messenger", charset="UTF-8"' if scheme == 'Basic' else 'Bearer realm="messenger"')
return result
@app.middleware("http")
async def request_context(request: Request, call_next):
request.state.request_id = uuid.uuid4().hex
logger.info("request start id=%s method=%s path=%s", reqid(request), request.method, request.url.path)
try:
path = request.url.path
if path == "/api/v1/users/me" or path.startswith("/api/v1/chats") or path == "/api/v1/auth/sessions/current":
# Authentication precedes resource and body validation.
request.state.actor = await run_in_threadpool(_authenticate, request)
if request.method == "POST" and (path in ("/api/v1/users", "/api/v1/chats") or (path.startswith("/api/v1/chats/") and path.endswith("/messages"))):
mime = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
if mime != "application/json":
raise APIError(415, "unsupported_media_type", "Content-Type must be application/json")
response = await call_next(request)
except APIError as exc:
response = error_response(request, exc.status, exc.code, exc.message)
except (psycopg.Error, PoolTimeout, redis.RedisError):
logger.warning("dependency unavailable request=%s", reqid(request))
response = error_response(request, 503, "unavailable", "Required dependency unavailable")
except Exception:
logger.exception("unexpected request error id=%s", reqid(request))
response = error_response(request, 500, "internal_error", "Internal server error")
response.headers["X-Request-Id"] = reqid(request)
logger.info("request end id=%s status=%s", reqid(request), response.status_code)
return response
@app.exception_handler(APIError)
async def api_error_handler(request: Request, exc: APIError):
return error_response(request, exc.status, exc.code, exc.message)
@app.exception_handler(RequestValidationError)
async def validation_error_handler(request: Request, exc: RequestValidationError):
return error_response(request, 400, "invalid_request", "Invalid request")
@app.exception_handler(psycopg.Error)
async def db_error_handler(request: Request, exc: psycopg.Error):
logger.warning("database error request=%s class=%s", reqid(request), type(exc).__name__)
return error_response(request, 503, "unavailable", "Required dependency unavailable")
@app.exception_handler(PoolTimeout)
async def pool_error_handler(request: Request, exc: PoolTimeout):
return error_response(request, 503, "unavailable", "Required dependency unavailable")
@app.exception_handler(redis.RedisError)
async def redis_error_handler(request: Request, exc: redis.RedisError):
return error_response(request, 503, "unavailable", "Required dependency unavailable")
@app.exception_handler(Exception)
async def unexpected_handler(request: Request, exc: Exception):
logger.exception("unexpected application error request=%s", reqid(request))
return error_response(request, 500, "internal_error", "Internal server error")
def valid_uuid(raw: str, name: str = "id") -> uuid.UUID:
try:
return uuid.UUID(raw)
except (ValueError, AttributeError, TypeError):
raise APIError(400, "invalid_request", f"Invalid {name}")
def limit_value(raw: str | None) -> int:
if raw is None:
return 50
if not re.fullmatch(r"[0-9]+", raw):
raise APIError(400, "invalid_request", "Invalid limit")
n = int(raw)
if n < 1 or n > 100:
raise APIError(400, "invalid_request", "Invalid limit")
return n
def from_db_utf8(value: bytes | memoryview) -> str:
"""Decode PostgreSQL bytea; unlike text/varchar it can contain U+0000.
The HTTP contract allows the full UTF-8 string range, including an escaped
JSON NUL. Pydantic checks Unicode code-point lengths before encoding;
the database enforces a conservative upper bound on byte length.
"""
return bytes(value).decode("utf-8")
def user_public(row: dict[str, Any]) -> dict[str, Any]:
return {"id": str(row["id"]), "username": row["username"], "display_name": from_db_utf8(row["display_name"]), "created_at": iso(row["created_at"])}
def chat_public(row: dict[str, Any]) -> dict[str, Any]:
return {"id": str(row["id"]), "title": from_db_utf8(row["title"]), "member_ids": [str(x) for x in row["member_ids"]], "created_at": iso(row["created_at"])}
def message_public(row: dict[str, Any]) -> dict[str, Any]:
return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]), "text": from_db_utf8(row["text"]), "created_at": iso(row["created_at"])}
def _authenticate(request: Request) -> dict[str, Any]:
auth = request.headers.get("authorization", "")
parts = auth.split(" ", 1)
if len(parts) != 2 or parts[0].lower() != "bearer" or not parts[1] or not re.fullmatch(r"[A-Za-z0-9_-]+", parts[1]):
raise APIError(401, "unauthorized", "Unauthorized")
token = parts[1]
digest = hashlib.sha256(token.encode("ascii")).hexdigest()
redis_key = "session:" + digest
user_id = request.app.state.sessions.get(redis_key)
if user_id is None:
raise APIError(401, "unauthorized", "Unauthorized")
try:
session_uid = uuid.UUID(user_id)
except (ValueError, AttributeError, TypeError):
# Corrupted Redis contents are not an authenticated identity. Fail
# closed and delete only the broken key, never invent a user or emit 500.
request.app.state.sessions.delete(redis_key)
raise APIError(401, "unauthorized", "Unauthorized")
with request.app.state.pool.connection() as conn:
row = conn.execute("SELECT id, username, display_name, created_at FROM users WHERE id = %s", (session_uid,)).fetchone()
if row is None:
raise APIError(401, "unauthorized", "Unauthorized")
actor = user_public(row)
request.state.session_digest = digest
return actor
def actor(request: Request) -> dict[str, Any]:
found = getattr(request.state, "actor", None)
return found if found is not None else _authenticate(request)
def basic_credentials(request: Request) -> tuple[str, str]:
auth = request.headers.get("authorization", "")
parts = auth.split(" ", 1)
if len(parts) != 2 or parts[0].lower() != "basic":
raise APIError(401, "unauthorized", "Unauthorized")
try:
raw = base64.b64decode(parts[1], validate=True).decode("utf-8")
username, password = raw.split(":", 1)
except (ValueError, UnicodeError, binascii.Error):
raise APIError(401, "unauthorized", "Unauthorized")
if not USERNAME_RE.fullmatch(username) or not password:
raise APIError(401, "unauthorized", "Unauthorized")
return username, password
def cursor_encode(payload: dict[str, str]) -> str:
return base64.urlsafe_b64encode(json.dumps(payload, separators=(",", ":")).encode("ascii")).decode("ascii").rstrip("=")
def cursor_decode(raw: str | None, *, kind: str, scope_key: str, scope_id: str) -> tuple[datetime, uuid.UUID] | None:
if raw is None:
return None
try:
if not raw or not re.fullmatch(r"[A-Za-z0-9_-]+", raw) or len(raw) > 1500:
raise ValueError("bad cursor")
value = json.loads(base64.urlsafe_b64decode(raw + ("=" * (-len(raw) % 4))))
if not isinstance(value, dict) or set(value) != {"kind", scope_key, "created_at", "id"}:
raise ValueError("bad cursor fields")
if value["kind"] != kind or value[scope_key] != scope_id:
raise ValueError("wrong cursor context")
stamp = value["created_at"]
if not isinstance(stamp, str) or not stamp.endswith("Z"):
raise ValueError("invalid timestamp")
when = datetime.fromisoformat(stamp.replace("Z", "+00:00"))
if when.utcoffset() != timedelta(0):
raise ValueError("not UTC")
return when, uuid.UUID(value["id"])
except (ValueError, TypeError, KeyError, UnicodeError, binascii.Error):
raise APIError(400, "invalid_request", "Invalid cursor")
def cursor_next(kind: str, scope_key: str, scope_id: str, row: dict[str, Any]) -> str:
return cursor_encode({"kind": kind, scope_key: scope_id, "created_at": iso(row["created_at"]), "id": str(row["id"])})
def read_chat(conn: psycopg.Connection, cid: uuid.UUID, uid: uuid.UUID) -> dict[str, Any]:
row = conn.execute("""
SELECT c.id, c.title, c.created_at,
ARRAY(SELECT cm2.user_id FROM chat_members cm2 WHERE cm2.chat_id=c.id ORDER BY cm2.position) AS member_ids
FROM chats c JOIN chat_members mine ON mine.chat_id=c.id
WHERE c.id=%s AND mine.user_id=%s
""", (cid, uid)).fetchone()
if row is None:
raise APIError(404, "not_found", "Object not found")
return row
@app.get("/health/live")
def live():
return {"status": "ok"}
@app.get("/health/ready")
def ready(request: Request):
with request.app.state.pool.connection() as conn:
conn.execute("SELECT 1")
request.app.state.sessions.ping()
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
def create_user(body: CreateUser, request: Request):
new_id = uuid.uuid4()
hashed = ph.hash(body.password)
try:
with request.app.state.pool.connection() as conn:
row = conn.execute("""
INSERT INTO users(id, username, display_name, password_hash)
VALUES (%s, %s, %s, %s) RETURNING id, username, display_name, created_at
""", (new_id, body.username, body.display_name.encode("utf-8"), hashed)).fetchone()
except UniqueViolation:
raise APIError(409, "conflict", "Username already exists")
return user_public(row)
@app.post("/api/v1/auth/sessions", status_code=201)
def create_session(request: Request):
# Contract: this endpoint uses Basic credentials only, never a JSON body.
if request.headers.get("content-length") not in (None, "", "0") or request.headers.get("transfer-encoding"):
raise APIError(400, "invalid_request", "Request body is not supported")
username, password = basic_credentials(request)
with request.app.state.pool.connection() as conn:
row = conn.execute("SELECT id, username, display_name, created_at, password_hash FROM users WHERE username=%s", (username,)).fetchone()
try:
is_valid = ph.verify(row["password_hash"] if row else DUMMY_HASH, password)
except (VerificationError, InvalidHashError):
is_valid = False
if row is None or not is_valid:
raise APIError(401, "unauthorized", "Unauthorized")
token = secrets.token_urlsafe(32) # 32 cryptographically random bytes (256 bits).
digest = hashlib.sha256(token.encode("ascii")).hexdigest()
ttl = request.app.state.session_ttl
request.app.state.sessions.set("session:" + digest, str(row["id"]), ex=ttl)
expiry = datetime.now(timezone.utc) + timedelta(seconds=ttl)
return {"token": token, "token_type": "Bearer", "expires_at": iso(expiry), "user": user_public(row)}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def logout(request: Request):
actor(request)
request.app.state.sessions.delete("session:" + request.state.session_digest)
return Response(status_code=204)
@app.get("/api/v1/users/me")
def users_me(request: Request):
return actor(request)
@app.post("/api/v1/chats", status_code=201)
def create_chat(request: Request, body: CreateChat):
uid = uuid.UUID(actor(request)["id"])
members = [valid_uuid(raw, "member_id") for raw in body.member_ids]
if len(set(members)) != len(members) or uid not in members:
raise APIError(400, "invalid_request", "Invalid chat members")
cid = uuid.uuid4()
with request.app.state.pool.connection() as conn:
with conn.transaction():
existing = conn.execute("SELECT id FROM users WHERE id=ANY(%s)", (members,)).fetchall()
if len(existing) != len(members):
raise APIError(400, "invalid_request", "Unknown member")
row = conn.execute("INSERT INTO chats(id, title) VALUES (%s,%s) RETURNING id,title,created_at", (cid, body.title.encode("utf-8"))).fetchone()
for index, member in enumerate(members):
conn.execute("INSERT INTO chat_members(chat_id,user_id,position) VALUES (%s,%s,%s)", (cid, member, index))
return chat_public({**row, "member_ids": members})
@app.get("/api/v1/chats")
def list_chats(request: Request, limit: str | None = Query(default=None), cursor: str | None = Query(default=None)):
uid = uuid.UUID(actor(request)["id"])
size = limit_value(limit)
key = cursor_decode(cursor, kind="chats", scope_key="user_id", scope_id=str(uid))
with request.app.state.pool.connection() as conn:
if key:
match = conn.execute("""
SELECT 1 FROM chats c JOIN chat_members cm ON c.id=cm.chat_id
WHERE cm.user_id=%s AND c.id=%s AND c.created_at=%s
""", (uid, key[1], key[0])).fetchone()
if match is None:
raise APIError(400, "invalid_request", "Invalid cursor")
query = """
SELECT c.id,c.title,c.created_at,
ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id=c.id ORDER BY m.position) AS member_ids
FROM chats c JOIN chat_members cm ON cm.chat_id=c.id
WHERE cm.user_id=%s
"""
params: list[Any] = [uid]
if key:
query += " AND (c.created_at,c.id)>(%s,%s)"
params.extend(key)
query += " ORDER BY c.created_at,c.id LIMIT %s"
rows = conn.execute(query, [*params, size+1]).fetchall()
page = rows[:size]
return {"items": [chat_public(r) for r in page], "next_cursor": cursor_next("chats", "user_id", str(uid), page[-1]) if len(rows)>size else None}
@app.get("/api/v1/chats/{chat_id}")
def get_chat(chat_id: str, request: Request):
uid = uuid.UUID(actor(request)["id"])
with request.app.state.pool.connection() as conn:
row = read_chat(conn, valid_uuid(chat_id, "chat_id"), uid)
return chat_public(row)
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def create_message(chat_id: str, request: Request, body: CreateMessage):
uid = uuid.UUID(actor(request)["id"])
cid = valid_uuid(chat_id, "chat_id")
with request.app.state.pool.connection() as conn:
read_chat(conn, cid, uid)
row = conn.execute("""
INSERT INTO messages(id,chat_id,sender_id,text)
VALUES (%s,%s,%s,%s) RETURNING id,chat_id,sender_id,text,created_at
""", (uuid.uuid4(), cid, uid, body.text.encode("utf-8"))).fetchone()
return message_public(row)
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(chat_id: str, request: Request, limit: str | None = Query(default=None), cursor: str | None = Query(default=None)):
uid = uuid.UUID(actor(request)["id"])
cid = valid_uuid(chat_id, "chat_id")
size = limit_value(limit)
key = cursor_decode(cursor, kind="messages", scope_key="chat_id", scope_id=str(cid))
with request.app.state.pool.connection() as conn:
read_chat(conn, cid, uid)
if key:
found = conn.execute("SELECT 1 FROM messages WHERE chat_id=%s AND id=%s AND created_at=%s", (cid, key[1], key[0])).fetchone()
if not found:
raise APIError(400, "invalid_request", "Invalid cursor")
query = """
SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=%s
"""
params: list[Any] = [cid]
if key:
query += " AND (created_at,id)>(%s,%s)"
params.extend(key)
query += " ORDER BY created_at,id LIMIT %s"
rows = conn.execute(query, [*params, size+1]).fetchall()
page = rows[:size]
return {"items": [message_public(r) for r in page], "next_cursor": cursor_next("messages", "chat_id", str(cid), page[-1]) if len(rows)>size else None}