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")))