import os import base64 import secrets import uuid from datetime import datetime, timezone, timedelta from typing import List, Optional from uuid import UUID import psycopg2 import psycopg2.extras import bcrypt from fastapi import FastAPI, Header, HTTPException, Query, Response, Request from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse from pydantic import BaseModel, Field, field_validator, ConfigDict import redis app = FastAPI(title="MTUSI Messenger — lab2", version="1.2.0") DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://postgres:postgres@postgres:5432/messenger") SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) REDIS_URL = os.getenv("REDIS_URL", "redis://redis:6379/0") redis_client = redis.Redis.from_url(REDIS_URL, decode_responses=True) def get_db_connection(): conn = psycopg2.connect(DATABASE_URL, cursor_factory=psycopg2.extras.RealDictCursor) return conn def init_db(): conn = get_db_connection() with conn.cursor() as cur: cur.execute(""" CREATE TABLE IF NOT EXISTS users ( id UUID PRIMARY KEY, username VARCHAR(32) UNIQUE NOT NULL, display_name VARCHAR(100) NOT NULL, password_hash VARCHAR(255) NOT NULL, created_at TIMESTAMPTZ NOT NULL ); CREATE TABLE IF NOT EXISTS chats ( id UUID PRIMARY KEY, title VARCHAR(100) NOT NULL, created_at TIMESTAMPTZ NOT NULL ); CREATE TABLE IF NOT EXISTS chat_members ( chat_id UUID REFERENCES chats(id) ON DELETE CASCADE, user_id UUID REFERENCES users(id) ON DELETE CASCADE, PRIMARY KEY (chat_id, user_id) ); CREATE TABLE IF NOT EXISTS messages ( id UUID PRIMARY KEY, chat_id UUID REFERENCES chats(id) ON DELETE CASCADE, sender_id UUID REFERENCES users(id) ON DELETE CASCADE, text VARCHAR(4000) NOT NULL, created_at TIMESTAMPTZ NOT NULL ); CREATE INDEX IF NOT EXISTS idx_messages_chat_pagination ON messages(chat_id, created_at, id); """) conn.commit() conn.close() @app.on_event("startup") def startup_event(): init_db() def generate_request_id() -> str: return uuid.uuid4().hex def make_error_response( status_code: int, code: str, message: str, req_id: str, extra_headers: Optional[dict] = None, ) -> JSONResponse: headers = {"X-Request-Id": req_id, "X-Instance-Id": "instance-1"} if extra_headers: headers.update(extra_headers) return JSONResponse( status_code=status_code, headers=headers, content={ "error": { "code": code, "message": message, "request_id": req_id, } }, ) @app.exception_handler(RequestValidationError) async def validation_exception_handler(request: Request, exc: RequestValidationError): req_id = request.headers.get("X-Request-Id") or generate_request_id() return make_error_response( status_code=400, code="invalid_request", message="Validation error in request body or parameters", req_id=req_id ) @app.exception_handler(HTTPException) async def http_exception_handler(request: Request, exc: HTTPException): req_id = request.headers.get("X-Request-Id") or generate_request_id() headers = {"X-Request-Id": req_id, "X-Instance-Id": "instance-1"} if exc.headers: headers.update(exc.headers) detail = exc.detail if isinstance(detail, dict) and "error" in detail: detail["error"]["request_id"] = req_id return JSONResponse(status_code=exc.status_code, headers=headers, content=detail) code_map = { 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", } return JSONResponse( status_code=exc.status_code, headers=headers, content={ "error": { "code": code_map.get(exc.status_code, "internal_error"), "message": str(detail), "request_id": req_id, } }, ) class CreateUser(BaseModel): model_config = ConfigDict(extra='forbid') username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$") display_name: str = Field(..., min_length=1, max_length=100) password: str = Field(..., min_length=12, max_length=128) @field_validator("display_name", "password") def not_blank(cls, v): if not v.strip(): raise ValueError("Must not be blank") return v class CreateChat(BaseModel): model_config = ConfigDict(extra='forbid') title: str = Field(..., min_length=1, max_length=100) member_ids: List[uuid.UUID] = Field(..., min_items=1, max_items=100) @field_validator("title") def not_blank(cls, v): if not v.strip(): raise ValueError("Must not be blank") return v class CreateMessage(BaseModel): model_config = ConfigDict(extra='forbid') text: str = Field(..., min_length=1, max_length=4000) @field_validator("text") def not_blank(cls, v): if not v.strip(): raise ValueError("Must not be blank") return v @app.get("/health/live") def health_live(response: Response): req_id = generate_request_id() response.headers["X-Request-Id"] = req_id response.headers["X-Instance-Id"] = "instance-1" return {"status": "ok"} @app.get("/health/ready") def health_ready(response: Response): req_id = generate_request_id() response.headers["X-Request-Id"] = req_id response.headers["X-Instance-Id"] = "instance-1" try: conn = get_db_connection() conn.close() redis_client.ping() except Exception: raise HTTPException(status_code=503, detail="Database or Redis unavailable") return {"status": "ok"} @app.post("/api/v1/users", status_code=201) def register_user(body: CreateUser, response: Response): req_id = generate_request_id() response.headers["X-Request-Id"] = req_id response.headers["X-Instance-Id"] = "instance-1" password_hash = bcrypt.hashpw(body.password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8') user_id = str(uuid.uuid4()) created_at = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z") conn = get_db_connection() try: with conn.cursor() as cur: cur.execute( "INSERT INTO users (id, username, display_name, password_hash, created_at) VALUES (%s, %s, %s, %s, %s)", (user_id, body.username, body.display_name, password_hash, created_at) ) conn.commit() except psycopg2.errors.UniqueViolation: conn.rollback() raise HTTPException(status_code=409, detail={"error": {"code": "conflict", "message": "Username already taken", "request_id": req_id}}) finally: conn.close() return { "id": user_id, "username": body.username, "display_name": body.display_name, "created_at": created_at } @app.post("/api/v1/auth/sessions", status_code=201) def create_session(authorization: Optional[str] = Header(None), response: Response = None): req_id = generate_request_id() response.headers["X-Request-Id"] = req_id response.headers["X-Instance-Id"] = "instance-1" if not authorization or not authorization.startswith("Basic "): raise HTTPException( status_code=401, detail="Missing or invalid basic auth", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} ) try: encoded = authorization.split(" ")[1] decoded = base64.b64decode(encoded).decode("utf-8") username, password = decoded.split(":", 1) except Exception: raise HTTPException( status_code=401, detail="Invalid credentials format", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} ) conn = get_db_connection() with conn.cursor() as cur: cur.execute("SELECT * FROM users WHERE username = %s", (username,)) user = cur.fetchone() if not user or not bcrypt.checkpw(password.encode('utf-8'), user['password_hash'].encode('utf-8')): conn.close() raise HTTPException( status_code=401, detail="Invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} ) token = secrets.token_urlsafe(48) redis_client.setex(f"session:{token}", SESSION_TTL_SECONDS, user['id']) expires_at = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS) expires_at_str = expires_at.isoformat().replace("+00:00", "Z") created_at_str = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z") return { "token": token, "token_type": "Bearer", "expires_at": expires_at_str, "user": { "id": user['id'], "username": user['username'], "display_name": user['display_name'], "created_at": user['created_at'].isoformat().replace("+00:00", "Z") if isinstance(user['created_at'], datetime) else user['created_at'] } } def get_current_user_from_token(authorization: Optional[str] = Header(None)) -> dict: if not authorization or not authorization.startswith("Bearer "): raise HTTPException( status_code=401, detail="Missing or invalid bearer token", headers={"WWW-Authenticate": 'Bearer realm="messenger"'} ) token = authorization.split(" ")[1] try: user_id = redis_client.get(f"session:{token}") except Exception: raise HTTPException(status_code=503, detail="Session store unavailable") if not user_id: raise HTTPException( status_code=401, detail="Invalid or expired session token", headers={"WWW-Authenticate": 'Bearer realm="messenger"'} ) conn = get_db_connection() with conn.cursor() as cur: cur.execute("SELECT * FROM users WHERE id = %s", (user_id,)) row = cur.fetchone() conn.close() if not row: raise HTTPException( status_code=401, detail="User not found", headers={"WWW-Authenticate": 'Bearer realm="messenger"'} ) return { "id": row['id'], "username": row['username'], "display_name": row['display_name'], "created_at": row['created_at'].isoformat().replace("+00:00", "Z") if isinstance(row['created_at'], datetime) else row['created_at'] } @app.delete("/api/v1/auth/sessions/current", status_code=204) def revoke_session(authorization: Optional[str] = Header(None)): req_id = generate_request_id() if not authorization or not authorization.startswith("Bearer "): raise HTTPException( status_code=401, detail="Unauthorized", headers={"WWW-Authenticate": 'Bearer realm="messenger"'} ) token = authorization.split(" ")[1] deleted = redis_client.delete(f"session:{token}") if not deleted: raise HTTPException( status_code=401, detail="Invalid session token", headers={"WWW-Authenticate": 'Bearer realm="messenger"'} ) return Response( status_code=204, headers={ "X-Request-Id": req_id, "X-Instance-Id": "instance-1" }, ) @app.get("/api/v1/users/me") def current_user(response: Response, authorization: Optional[str] = Header(None)): req_id = generate_request_id() response.headers["X-Request-Id"] = req_id response.headers["X-Instance-Id"] = "instance-1" return get_current_user_from_token(authorization) @app.post("/api/v1/chats", status_code=201) def create_chat(body: CreateChat, response: Response, authorization: Optional[str] = Header(None)): req_id = generate_request_id() response.headers["X-Request-Id"] = req_id response.headers["X-Instance-Id"] = "instance-1" user = get_current_user_from_token(authorization) member_ids_str = [str(mid) for mid in body.member_ids] if user["id"] not in member_ids_str: raise HTTPException(status_code=400, detail="Caller must be in member_ids") if len(member_ids_str) != len(set(member_ids_str)): raise HTTPException(status_code=400, detail="Duplicate member IDs") conn = get_db_connection() with conn.cursor() as cur: for mid_str in member_ids_str: cur.execute("SELECT id FROM users WHERE id = %s", (mid_str,)) if not cur.fetchone(): conn.close() raise HTTPException(status_code=400, detail=f"User {mid_str} not found") chat_id = str(uuid.uuid4()) created_at = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z") conn = get_db_connection() try: with conn.cursor() as cur: cur.execute( "INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)", (chat_id, body.title, created_at) ) for mid_str in member_ids_str: cur.execute( "INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", (chat_id, mid_str) ) conn.commit() except Exception: conn.rollback() conn.close() raise HTTPException(status_code=500, detail="Internal error creating chat") conn.close() return { "id": chat_id, "title": body.title, "member_ids": member_ids_str, "created_at": created_at } @app.get("/api/v1/chats") def list_chats(limit: int = 50, cursor: Optional[str] = None, response: Response = None, authorization: Optional[str] = Header(None)): req_id = generate_request_id() response.headers["X-Request-Id"] = req_id response.headers["X-Instance-Id"] = "instance-1" user = get_current_user_from_token(authorization) if limit < 1 or limit > 100: raise HTTPException(status_code=400, detail="Invalid limit") conn = get_db_connection() with conn.cursor() as cur: cur.execute(""" SELECT c.id, c.title, c.created_at FROM chats c JOIN chat_members cm ON c.id = cm.chat_id WHERE cm.user_id = %s ORDER BY c.created_at ASC, c.id ASC """, (user["id"],)) rows = cur.fetchall() conn.close() user_chats = [] for r in rows: conn = get_db_connection() with conn.cursor() as cur: cur.execute("SELECT user_id FROM chat_members WHERE chat_id = %s", (r['id'],)) m_rows = cur.fetchall() conn.close() user_chats.append({ "id": r['id'], "title": r['title'], "member_ids": [m['user_id'] for m in m_rows], "created_at": r['created_at'].isoformat().replace("+00:00", "Z") if isinstance(r['created_at'], datetime) else r['created_at'] }) start_idx = 0 if cursor: try: parts = cursor.split("_") c_time, c_id = parts[0], parts[1] found = False for idx, c in enumerate(user_chats): if (c["created_at"], c["id"]) >= (c_time, c_id): start_idx = idx if (c["created_at"], c["id"]) > (c_time, c_id) else idx + 1 found = True break if not found: start_idx = len(user_chats) except Exception: raise HTTPException(status_code=400, detail="Invalid cursor format") page_items = user_chats[start_idx:start_idx + limit] next_cursor = None if start_idx + limit < len(user_chats): last = page_items[-1] next_cursor = f"{last['created_at']}_{last['id']}" return {"items": page_items, "next_cursor": next_cursor} @app.get("/api/v1/chats/{chat_id}") def get_chat(chat_id: UUID, response: Response, authorization: Optional[str] = Header(None)): req_id = generate_request_id() response.headers["X-Request-Id"] = req_id response.headers["X-Instance-Id"] = "instance-1" user = get_current_user_from_token(authorization) chat_id_str = str(chat_id) conn = get_db_connection() with conn.cursor() as cur: cur.execute(""" SELECT c.* FROM chats c JOIN chat_members cm ON c.id = cm.chat_id WHERE c.id = %s AND cm.user_id = %s """, (chat_id_str, user["id"])) chat = cur.fetchone() if chat: cur.execute("SELECT user_id FROM chat_members WHERE chat_id = %s", (chat_id_str,)) members = cur.fetchall() conn.close() if not chat: raise HTTPException(status_code=404, detail="Chat not found") return { "id": chat['id'], "title": chat['title'], "member_ids": [m['user_id'] for m in members], "created_at": chat['created_at'].isoformat().replace("+00:00", "Z") if isinstance(chat['created_at'], datetime) else chat['created_at'] } @app.post("/api/v1/chats/{chat_id}/messages", status_code=201) def create_message(chat_id: UUID, body: CreateMessage, response: Response, authorization: Optional[str] = Header(None)): req_id = generate_request_id() response.headers["X-Request-Id"] = req_id response.headers["X-Instance-Id"] = "instance-1" user = get_current_user_from_token(authorization) chat_id_str = str(chat_id) conn = get_db_connection() with conn.cursor() as cur: cur.execute(""" SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s """, (chat_id_str, user["id"])) if not cur.fetchone(): conn.close() raise HTTPException(status_code=404, detail="Chat not found") msg_id = str(uuid.uuid4()) created_at = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z") with conn.cursor() as cur: cur.execute( "INSERT INTO messages (id, chat_id, sender_id, text, created_at) VALUES (%s, %s, %s, %s, %s)", (msg_id, chat_id_str, user["id"], body.text, created_at) ) conn.commit() conn.close() return { "id": msg_id, "chat_id": chat_id_str, "sender_id": user["id"], "text": body.text, "created_at": created_at } @app.get("/api/v1/chats/{chat_id}/messages") def list_messages(chat_id: UUID, limit: int = 50, cursor: Optional[str] = None, response: Response = None, authorization: Optional[str] = Header(None)): req_id = generate_request_id() response.headers["X-Request-Id"] = req_id response.headers["X-Instance-Id"] = "instance-1" user = get_current_user_from_token(authorization) chat_id_str = str(chat_id) conn = get_db_connection() if limit < 1 or limit > 100: raise HTTPException(status_code=400, detail="Invalid limit") query = """ SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s """ params = [chat_id_str] if cursor: try: parts = cursor.split("_") c_time, c_id = parts[0], parts[1] query += " AND (created_at, id) > (%s, %s)" params.extend([c_time, c_id]) except Exception: conn.close() raise HTTPException(status_code=400, detail="Invalid cursor format") query += " ORDER BY created_at ASC, id ASC LIMIT %s" params.append(limit + 1) with conn.cursor() as cur: cur.execute(query, tuple(params)) rows = cur.fetchall() conn.close() has_next = len(rows) > limit page_items = rows[:limit] formatted_msgs = [] for m in page_items: formatted_msgs.append({ "id": m['id'], "chat_id": m['chat_id'], "sender_id": m['sender_id'], "text": m['text'], "created_at": m['created_at'].isoformat().replace("+00:00", "Z") if isinstance(m['created_at'], datetime) else m['created_at'] }) next_cursor = None if has_next and formatted_msgs: last = formatted_msgs[-1] next_cursor = f"{last['created_at']}_{last['id']}" return {"items": formatted_msgs, "next_cursor": next_cursor}