Files
mtusi2026lab5/app/main.py
T

282 lines
13 KiB
Python

import os
import socket
import uuid
import hashlib
import json
from contextvars import ContextVar
from datetime import datetime, timedelta, timezone
from typing import Optional
from uuid import UUID
from fastapi import Depends, FastAPI, Header, HTTPException, Query, Request, Response
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from sqlalchemy import select, text
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
from starlette.middleware.base import BaseHTTPMiddleware
from .auth import (
SESSION_TTL, create_session, get_current_user,
hash_password, revoke_current_session, verify_password,
)
from .db.models import IdempotencyRecord, User, Attachment, MessageAttachment
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
from .s3_client import s3, BUCKET, ensure_bucket
from .image_utils import validate_image
INSTANCE_ID = os.environ.get("HOSTNAME", f"api-{socket.gethostname()}")
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 — lab4")
app.add_middleware(RequestIdMiddleware)
security = HTTPBasic(auto_error=False)
@app.on_event("startup")
def startup_event():
ensure_bucket()
@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, attachment_ids=None) -> 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),
"attachment_ids": [str(a) for a in (attachment_ids or [])]
}
def _attachment_json(att: Attachment) -> dict:
return {
"id": str(att.id), "chat_id": str(att.chat_id), "owner_id": str(att.owner_id),
"filename": att.filename, "content_type": att.content_type, "size_bytes": att.size_bytes,
"sha256": att.sha256, "status": att.status, "error_code": att.error_code,
"variants": [],
"created_at": _iso_z(att.created_at),
"updated_at": _iso_z(att.updated_at),
}
@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"}
@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)
@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(401, "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(401, "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)
@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])
@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")
if not body.text.strip() and not body.attachment_ids:
raise HTTPException(400, "Empty message without attachments")
req_hash = hashlib.sha256(body.model_dump_json().encode("utf-8")).hexdigest()
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")
return JSONResponse(status_code=201, content=json.loads(record.response_body))
msg = await messages_repo.create_and_invalidate(db, chat_id, user.id, body.text)
if body.attachment_ids:
for att_id in body.attachment_ids:
att = await db.get(Attachment, att_id)
if not att or att.chat_id != chat_id:
raise HTTPException(404, f"Attachment {att_id} not found in this chat")
db.add(MessageAttachment(message_id=msg.id, attachment_id=att_id))
resp_dict = _msg_json(msg, body.attachment_ids)
resp_body = json.dumps(resp_dict)
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)
msg_ids = [m.id for m in rows]
att_map = {}
if msg_ids:
att_stmt = select(MessageAttachment.message_id, MessageAttachment.attachment_id).where(MessageAttachment.message_id.in_(msg_ids))
att_rows = (await db.execute(att_stmt)).all()
for mid, aid in att_rows: att_map.setdefault(mid, []).append(aid)
items = [_msg_json(m, att_map.get(m.id, [])) for m in rows]
nxt = f"{next_cursor[0].isoformat()}|{next_cursor[1]}" if next_cursor else None
return {"items": items, "next_cursor": nxt}
@app.post("/api/v1/chats/{chat_id}/attachments", status_code=201)
async def upload_attachment(chat_id: UUID, request: Request, filename: str = Query(..., min_length=1, max_length=255), user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
chat = await chats_repo.get_if_member(db, chat_id, user.id)
if not chat: raise HTTPException(404, "Chat not found")
content = await request.body()
mime = validate_image(content)
sha256 = hashlib.sha256(content).hexdigest()
ext = ".png" if mime == "image/png" else ".jpg"
s3_key = f"{chat_id}/{uuid.uuid4()}{ext}"
s3.put_object(Bucket=BUCKET, Key=s3_key, Body=content, ContentType=mime)
att = Attachment(chat_id=chat_id, owner_id=user.id, filename=filename, content_type=mime, size_bytes=len(content), sha256=sha256, status="ready", s3_key=s3_key)
db.add(att)
await db.commit()
await db.refresh(att)
return _attachment_json(att)
@app.get("/api/v1/attachments/{attachment_id}")
async def get_attachment(attachment_id: UUID, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
att = await db.get(Attachment, attachment_id)
if not att: raise HTTPException(404, "Attachment not found")
chat = await chats_repo.get_if_member(db, att.chat_id, user.id)
if not chat: raise HTTPException(404, "Attachment not found")
return _attachment_json(att)
@app.get("/api/v1/attachments/{attachment_id}/content")
async def download_attachment(attachment_id: UUID, user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
att = await db.get(Attachment, attachment_id)
if not att: raise HTTPException(404, "Attachment not found")
chat = await chats_repo.get_if_member(db, att.chat_id, user.id)
if not chat: raise HTTPException(404, "Attachment not found")
obj = s3.get_object(Bucket=BUCKET, Key=att.s3_key)
content = obj["Body"].read()
return Response(content=content, media_type=att.content_type)
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("APP_PORT", "8080")))