Files
mtusi2026lab4/app/main.py
T

336 lines
11 KiB
Python

import os
import uuid
import socket
from contextvars import ContextVar
from datetime import datetime, timedelta, timezone
from typing import Optional
from uuid import UUID
from sqlalchemy.exc import IntegrityError
import hashlib
import json
INSTANCE_ID = os.environ.get("HOSTNAME", f"api-{socket.gethostname()}")
from fastapi import Depends, FastAPI, Header, HTTPException, Query, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from sqlalchemy import select, text
from sqlalchemy.ext.asyncio import AsyncSession
from starlette.middleware.base import BaseHTTPMiddleware
from .auth import (
SESSION_TTL,
create_session,
generate_token,
get_current_user,
hash_password,
hash_token,
revoke_current_session,
verify_password,
)
from .db.models import IdempotencyRecord, SessionRow, User
from .db.session import get_db
from .models import CreateChat, CreateMessage, CreateUser
from .repositories import chats as chats_repo
from .repositories import messages as messages_repo
from .repositories import users as users_repo
request_id_var: ContextVar[str] = ContextVar("request_id", default="")
_HTTP_CODES = {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
503: "unavailable",
500: "internal_error",
}
def err_json(status: int, code: str, message: str) -> JSONResponse:
resp = JSONResponse(
status_code=status,
content={
"error": {
"code": code,
"message": message,
"request_id": request_id_var.get(),
}
},
)
resp.headers["X-Instance-Id"] = INSTANCE_ID
return resp
class RequestIdMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request: Request, call_next):
rid = request.headers.get("X-Request-Id") or uuid.uuid4().hex
request_id_var.set(rid)
response = await call_next(request)
response.headers["X-Request-Id"] = rid
response.headers["X-Instance-Id"] = INSTANCE_ID
return response
app = FastAPI(title="MTUSI Messenger — lab2")
app.add_middleware(RequestIdMiddleware)
security = HTTPBasic(auto_error=False)
@app.exception_handler(RequestValidationError)
async def _validation(request: Request, exc: RequestValidationError):
return err_json(400, "invalid_request", "Validation error")
@app.exception_handler(HTTPException)
async def _http(request: Request, exc: HTTPException):
code = _HTTP_CODES.get(exc.status_code, "internal_error")
detail = exc.detail if isinstance(exc.detail, str) else "Error"
resp = err_json(exc.status_code, code, detail)
if exc.headers:
for k, v in exc.headers.items():
resp.headers[k] = v
return resp
@app.exception_handler(Exception)
async def _generic(request: Request, exc: Exception):
return err_json(500, "internal_error", "Internal server error")
def _iso_z(dt: datetime) -> str:
return dt.isoformat().replace("+00:00", "Z")
def _user_json(u: User) -> dict:
return {
"id": str(u.id),
"username": u.username,
"display_name": u.display_name,
"created_at": _iso_z(u.created_at),
}
def _chat_json(chat, member_ids: list[str]) -> dict:
return {
"id": str(chat.id),
"title": chat.title,
"member_ids": member_ids,
"created_at": _iso_z(chat.created_at),
}
def _msg_json(m) -> dict:
return {
"id": str(m.id),
"chat_id": str(m.chat_id),
"sender_id": str(m.sender_id),
"text": m.text,
"created_at": _iso_z(m.created_at),
}
# ---------- health ----------
@app.get("/health/live")
def live():
return {"status": "ok"}
@app.get("/health/ready")
async def ready(db: AsyncSession = Depends(get_db)):
try:
await db.execute(text("SELECT 1"))
except Exception:
return err_json(503, "unavailable", "Database unavailable")
return {"status": "ok"}
# ---------- users ----------
@app.post("/api/v1/users", status_code=201)
async def register(body: CreateUser, db: AsyncSession = Depends(get_db)):
existing = await users_repo.get_by_username(db, body.username)
if existing is not None:
raise HTTPException(409, "Username already exists")
try:
user = await users_repo.create(
db, body.username, body.display_name, hash_password(body.password)
)
except Exception:
raise HTTPException(409, "Username already exists")
return _user_json(user)
# ---------- sessions ----------
@app.post("/api/v1/auth/sessions", status_code=201)
async def login(
creds: Optional[HTTPBasicCredentials] = Depends(security),
db: AsyncSession = Depends(get_db),
):
basic_challenge = 'Basic realm="messenger", charset="UTF-8"'
if creds is None:
raise HTTPException(
status_code=401, detail="Unauthorized", headers={"WWW-Authenticate": basic_challenge}
)
user = await users_repo.get_by_username(db, creds.username)
if user is None or not verify_password(creds.password, user.password_hash):
raise HTTPException(
status_code=401, detail="Unauthorized", headers={"WWW-Authenticate": basic_challenge}
)
expires = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL)
token = await create_session(str(user.id))
return {
"token": token,
"token_type": "Bearer",
"expires_at": _iso_z(expires),
"user": _user_json(user),
}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def logout(authorization: str = Header(...), db: AsyncSession = Depends(get_db)):
await revoke_current_session(authorization, db)
@app.get("/api/v1/users/me")
async def me(user: User = Depends(get_current_user)):
return _user_json(user)
# ---------- chats ----------
@app.post("/api/v1/chats", status_code=201)
async def create_chat(
body: CreateChat,
user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
if user.id not in body.member_ids:
raise HTTPException(400, "Caller must be in member_ids")
try:
chat = await chats_repo.create_atomic(db, body.title, body.member_ids)
except ValueError:
raise HTTPException(404, "Member not found")
return _chat_json(chat, [str(x) for x in body.member_ids])
@app.get("/api/v1/chats")
async def list_chats(
user: User = Depends(get_current_user),
limit: int = Query(50, ge=1, le=100),
cursor: Optional[str] = Query(None, min_length=1),
db: AsyncSession = Depends(get_db),
):
parsed = None
if cursor is not None:
try:
c_created, c_id = cursor.split("|", 1)
parsed = (datetime.fromisoformat(c_created), UUID(c_id))
except Exception:
raise HTTPException(400, "Invalid cursor")
rows, next_cursor = await chats_repo.list_for_user(db, user.id, limit, parsed)
items = []
for chat in rows:
members = await chats_repo.list_member_ids(db, chat.id)
items.append(_chat_json(chat, [str(m) for m in members]))
nxt = f"{next_cursor[0].isoformat()}|{next_cursor[1]}" if next_cursor else None
return {"items": items, "next_cursor": nxt}
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(
chat_id: UUID,
user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
chat = await chats_repo.get_if_member(db, chat_id, user.id)
if chat is None:
raise HTTPException(404, "Chat not found")
members = await chats_repo.list_member_ids(db, chat.id)
return _chat_json(chat, [str(m) for m in members])
# ---------- messages ----------
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def post_message(
chat_id: UUID,
body: CreateMessage,
idempotency_key: str = Header(..., alias="Idempotency-Key"),
user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
chat = await chats_repo.get_if_member(db, chat_id, user.id)
if chat is None:
raise HTTPException(404, "Chat not found")
req_hash = hashlib.sha256(body.model_dump_json().encode("utf-8")).hexdigest()
# 1. Проверяем, есть ли уже такой ключ
stmt = select(IdempotencyRecord).where(
IdempotencyRecord.user_id == user.id,
IdempotencyRecord.key == idempotency_key,
)
record = (await db.execute(stmt)).scalar_one_or_none()
if record:
if record.request_hash != req_hash:
raise HTTPException(409, "Idempotency key conflict")
# Возвращаем сохраненный ответ (201 и тот же JSON)
return JSONResponse(status_code=201, content=json.loads(record.response_body))
# 2. Создаём сообщение
msg = await messages_repo.create_and_invalidate(db, chat_id, user.id, body.text)
resp_body = json.dumps(_msg_json(msg))
# 3. Сохраняем ключ
db.add(IdempotencyRecord(
user_id=user.id,
key=idempotency_key,
request_hash=req_hash,
response_body=resp_body
))
try:
await db.commit()
except IntegrityError:
# Гонка: другая реплика уже вставила этот ключ
await db.rollback()
record = (await db.execute(stmt)).scalar_one_or_none()
if record and record.request_hash == req_hash:
return JSONResponse(status_code=201, content=json.loads(record.response_body))
raise HTTPException(409, "Idempotency key conflict")
return JSONResponse(status_code=201, content=json.loads(resp_body))
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(
chat_id: UUID,
user: User = Depends(get_current_user),
limit: int = Query(50, ge=1, le=100),
cursor: Optional[str] = Query(None, min_length=1),
db: AsyncSession = Depends(get_db),
):
chat = await chats_repo.get_if_member(db, chat_id, user.id)
if chat is None:
raise HTTPException(404, "Chat not found")
parsed = None
if cursor is not None:
try:
c_created, c_id = cursor.split("|", 1)
parsed = (datetime.fromisoformat(c_created), UUID(c_id))
except Exception:
raise HTTPException(400, "Invalid cursor")
rows, next_cursor, _cached = await messages_repo.list_page_cached(db, chat_id, limit, parsed)
nxt = f"{next_cursor[0].isoformat()}|{next_cursor[1]}" if next_cursor else None
return {"items": [_msg_json(m) for m in rows], "next_cursor": nxt}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("APP_PORT", "8080")))