import hashlib import logging import secrets from contextlib import asynccontextmanager from uuid import UUID, uuid4 import anyio import psycopg from fastapi import Depends, FastAPI, Query, Request, Response from fastapi.exceptions import RequestValidationError from psycopg_pool import PoolTimeout, TooManyRequests from starlette.exceptions import HTTPException from src import store from src.cache import profile from src.config import SESSION_TTL from src.db import connection, migrate, pool from src.errors import ApiError, error_response from src.models import Chat, ChatPage, CreateChat, CreateMessage, CreateUser, Message, MessagePage, User from src.security import basic_credentials, hasher, token_hash, unauthorized, verify @asynccontextmanager async def lifespan(app): # Startup happens before serving requests; migrations also work via python -m src.db. anyio.to_thread.current_default_thread_limiter().total_tokens = 16 migrate() pool.open() pool.wait(timeout=10) yield pool.close() app = FastAPI(title="MTUSI Messenger", version="1.2.0", lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None) def failure(request, status, code, message): response = error_response(request, status, code, message) if status == 401: basic = request.url.path == "/api/v1/auth/sessions" response.headers['WWW-Authenticate'] = ('Basic realm="messenger", charset="UTF-8"' if basic else 'Bearer realm="messenger"') return response @app.middleware("http") async def request_context(request, call_next): request.state.request_id = str(uuid4()) try: if request.method == "POST" and request.url.path == "/api/v1/auth/sessions" and await request.body(): raise ApiError(400, "invalid_request", "Вход не принимает тело запроса") response = await call_next(request) except ApiError as exc: response = failure(request, exc.status_code, exc.code, exc.message) except (psycopg.Error, PoolTimeout, TooManyRequests): response = failure(request, 503, "unavailable", "Хранилище временно недоступно") except Exception as exc: logging.error("Unhandled request error: %s", type(exc).__name__) response = failure(request, 500, "internal_error", "Внутренняя ошибка сервера") response.headers['X-Request-Id'] = request.state.request_id return response @app.exception_handler(ApiError) async def api_error(request, exc): return failure(request, exc.status_code, exc.code, exc.message) @app.exception_handler(RequestValidationError) async def validation_error(request, exc): return failure(request, 400, "invalid_request", "Некорректный запрос") @app.exception_handler(HTTPException) async def http_error(request, exc): return failure(request, exc.status_code, "not_found" if exc.status_code == 404 else "invalid_request", "Недопустимый HTTP-запрос") def require_user(request: Request): digest = token_hash(request.headers.get('Authorization')) with connection() as conn: row = conn.execute("SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at > clock_timestamp()", (digest,)).fetchone() if row is None: unauthorized() user_id = str(row['user_id']) user = profile(user_id, lambda: store.load_user(user_id)) if user is None: unauthorized() request.state.token_hash = digest return User(**user) @app.get('/health/live') def live(): return {"status": "ok"} @app.get('/health/ready') def ready(): with connection() as conn: conn.execute("SELECT 1").fetchone() return {"status": "ok"} @app.post('/api/v1/users', status_code=201, response_model=User) def register(data: CreateUser): return store.create_user(data, hasher.hash(data.password)) @app.post('/api/v1/auth/sessions', status_code=201) def login(request: Request): username, password = basic_credentials(request.headers.get('Authorization')) with connection() as conn: row = conn.execute("SELECT id,username,display_name,created_at,password_hash FROM users WHERE username=%s", (username,)).fetchone() valid = verify(row['password_hash'] if row else None, password) if not row or not valid: unauthorized() token = secrets.token_urlsafe(32) digest = hashlib.sha256(token.encode('ascii')).digest() with connection() as conn: result = conn.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,clock_timestamp() + %s * interval '1 second') RETURNING expires_at", (digest, row['id'], SESSION_TTL)).fetchone() del row['password_hash'] return {"token": token, "token_type": "Bearer", "expires_at": store.public(result['expires_at']), "user": store.public(row)} @app.delete('/api/v1/auth/sessions/current', status_code=204) def logout(request: Request, user: User = Depends(require_user)): with connection() as conn: conn.execute("DELETE FROM sessions WHERE token_hash=%s", (request.state.token_hash,)) return Response(status_code=204) @app.get('/api/v1/users/me', response_model=User) def me(user: User = Depends(require_user)): return user @app.post('/api/v1/chats', status_code=201, response_model=Chat) def create_chat(data: CreateChat, user: User = Depends(require_user)): return store.create_chat(data, user.id) @app.get('/api/v1/chats', response_model=ChatPage) def chats(user: User = Depends(require_user), limit: int = Query(50, ge=1, le=100), cursor: str | None = Query(None, min_length=1, max_length=2048)): return store.list_chats(user.id, limit, cursor) @app.get('/api/v1/chats/{chat_id}', response_model=Chat) def chat(chat_id: UUID, user: User = Depends(require_user)): return store.get_chat(str(chat_id), user.id) @app.post('/api/v1/chats/{chat_id}/messages', status_code=201, response_model=Message) def send(chat_id: UUID, data: CreateMessage, user: User = Depends(require_user)): return store.create_message(str(chat_id), user.id, data.text) @app.get('/api/v1/chats/{chat_id}/messages', response_model=MessagePage) def history(chat_id: UUID, user: User = Depends(require_user), limit: int = Query(50, ge=1, le=100), cursor: str | None = Query(None, min_length=1, max_length=2048)): return store.list_messages(str(chat_id), user.id, limit, cursor)