forked from mtusi2026/mtusi2026lab4
282 lines
13 KiB
Python
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"))) |