379 lines
13 KiB
Python
379 lines
13 KiB
Python
import base64
|
|
import json
|
|
import logging
|
|
import re
|
|
from contextlib import asynccontextmanager
|
|
from datetime import datetime
|
|
from typing import Any, Callable, Dict, Optional, Tuple
|
|
from uuid import UUID, uuid4
|
|
|
|
import psycopg
|
|
from fastapi import Depends, FastAPI, Query, Request, Response
|
|
from fastapi.exceptions import RequestValidationError
|
|
from fastapi.responses import JSONResponse
|
|
from psycopg_pool import PoolTimeout
|
|
from starlette.exceptions import HTTPException as StarletteHTTPException
|
|
from starlette.middleware.base import BaseHTTPMiddleware
|
|
|
|
from .config import load_settings
|
|
from .db import create_pool, wait_and_migrate
|
|
from .models import (
|
|
Chat,
|
|
ChatCreate,
|
|
ChatPage,
|
|
Message,
|
|
MessageCreate,
|
|
MessagePage,
|
|
Session,
|
|
User,
|
|
UserCreate,
|
|
)
|
|
from .security import hash_password, parse_basic, parse_bearer, verify_password
|
|
from .sessions import SessionCache, SessionService
|
|
from .storage import Storage, UnknownMember, UsernameTaken
|
|
|
|
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
|
|
log = logging.getLogger("messenger.api")
|
|
|
|
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
|
|
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
|
REQUEST_ID_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app: FastAPI):
|
|
settings = load_settings()
|
|
applied = wait_and_migrate(settings)
|
|
log.info("migrations applied at startup: %s", applied or "none")
|
|
pool = create_pool(settings)
|
|
storage = Storage(pool)
|
|
cache = SessionCache(settings)
|
|
app.state.settings = settings
|
|
app.state.storage = storage
|
|
app.state.cache = cache
|
|
app.state.sessions = SessionService(storage, cache, settings)
|
|
log.info(
|
|
"started: session_ttl=%ss cache=%s pool=%s..%s",
|
|
settings.session_ttl_seconds,
|
|
"redis" if cache.client is not None else "disabled",
|
|
settings.db_pool_min,
|
|
settings.db_pool_max,
|
|
)
|
|
try:
|
|
yield
|
|
finally:
|
|
pool.close()
|
|
if cache.client is not None:
|
|
cache.client.close()
|
|
|
|
|
|
app = FastAPI(
|
|
title="MTUSI Messenger (PostgreSQL + Redis)",
|
|
version="2.0.0",
|
|
lifespan=lifespan,
|
|
)
|
|
|
|
|
|
# Request ID
|
|
|
|
class RequestIdMiddleware(BaseHTTPMiddleware):
|
|
async def dispatch(self, request: Request, call_next: Callable):
|
|
incoming = request.headers.get("X-Request-Id", "")
|
|
request_id = incoming if REQUEST_ID_RE.match(incoming) else str(uuid4())
|
|
request.state.request_id = request_id
|
|
response = await call_next(request)
|
|
response.headers["X-Request-Id"] = request_id
|
|
return response
|
|
|
|
|
|
app.add_middleware(RequestIdMiddleware)
|
|
|
|
|
|
# errors
|
|
|
|
class ApiError(Exception):
|
|
def __init__(self, status_code: int, code: str, message: str, headers: Optional[Dict[str, str]] = None):
|
|
self.status_code = status_code
|
|
self.code = code
|
|
self.message = message
|
|
self.headers = headers or {}
|
|
|
|
|
|
def unauthorized(challenge: str = BEARER_CHALLENGE) -> ApiError:
|
|
return ApiError(401, "unauthorized", "Authentication required", {"WWW-Authenticate": challenge})
|
|
|
|
|
|
def bad_request(message: str = "Invalid request") -> ApiError:
|
|
return ApiError(400, "invalid_request", message)
|
|
|
|
|
|
def not_found() -> ApiError:
|
|
return ApiError(404, "not_found", "Not found")
|
|
|
|
|
|
def error_response(
|
|
request: Request,
|
|
status_code: int,
|
|
code: str,
|
|
message: str,
|
|
headers: Optional[Dict[str, str]] = None,
|
|
) -> JSONResponse:
|
|
request_id = getattr(request.state, "request_id", None) or str(uuid4())
|
|
all_headers = {"X-Request-Id": request_id}
|
|
all_headers.update(headers or {})
|
|
return JSONResponse(
|
|
status_code=status_code,
|
|
content={"error": {"code": code, "message": message, "request_id": request_id}},
|
|
headers=all_headers,
|
|
)
|
|
|
|
|
|
@app.exception_handler(ApiError)
|
|
async def api_error_handler(request: Request, exc: ApiError) -> JSONResponse:
|
|
return error_response(request, exc.status_code, exc.code, exc.message, exc.headers)
|
|
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
|
|
return error_response(request, 400, "invalid_request", "Invalid request")
|
|
|
|
|
|
@app.exception_handler(StarletteHTTPException)
|
|
async def http_exception_handler(request: Request, exc: StarletteHTTPException) -> JSONResponse:
|
|
status_to_code = {
|
|
400: "invalid_request",
|
|
401: "unauthorized",
|
|
404: "not_found",
|
|
409: "conflict",
|
|
413: "payload_too_large",
|
|
415: "unsupported_media_type",
|
|
429: "rate_limited",
|
|
503: "unavailable",
|
|
}
|
|
status_code = exc.status_code if exc.status_code in status_to_code else 500
|
|
code = status_to_code.get(status_code, "internal_error")
|
|
message = str(exc.detail) if status_code != 500 else "Internal server error"
|
|
return error_response(request, status_code, code, message)
|
|
|
|
|
|
async def dependency_unavailable(request: Request, exc: Exception) -> JSONResponse:
|
|
# Наружу — только общий 503, без SQL, адресов и текста драйвера.
|
|
log.warning("database unavailable: %s", type(exc).__name__)
|
|
return error_response(request, 503, "unavailable", "Service temporarily unavailable")
|
|
|
|
|
|
app.add_exception_handler(psycopg.OperationalError, dependency_unavailable)
|
|
app.add_exception_handler(psycopg.InterfaceError, dependency_unavailable)
|
|
app.add_exception_handler(PoolTimeout, dependency_unavailable)
|
|
|
|
|
|
@app.exception_handler(Exception)
|
|
async def unexpected_exception_handler(request: Request, exc: Exception) -> JSONResponse:
|
|
log.exception("unexpected error")
|
|
return error_response(request, 500, "internal_error", "Internal server error")
|
|
|
|
|
|
# helpers
|
|
|
|
def require_json_content_type(request: Request) -> None:
|
|
content_type = request.headers.get("content-type", "")
|
|
if not content_type.lower().startswith("application/json"):
|
|
raise ApiError(415, "unsupported_media_type", "Unsupported media type")
|
|
|
|
|
|
def ensure_not_blank(value: str) -> None:
|
|
if not value.strip():
|
|
raise bad_request()
|
|
|
|
|
|
def storage_of(request: Request) -> Storage:
|
|
return request.app.state.storage
|
|
|
|
|
|
def current_user(request: Request) -> User:
|
|
"""Только Authorization: Bearer. Basic и X-User-Id здесь не дают доступа."""
|
|
token = parse_bearer(request.headers.get("Authorization"))
|
|
if token is None:
|
|
raise unauthorized()
|
|
user = request.app.state.sessions.resolve(token)
|
|
if user is None:
|
|
raise unauthorized()
|
|
request.state.token = token
|
|
return user
|
|
|
|
|
|
def encode_cursor(resource_id: UUID, created_at: datetime, item_id: UUID) -> str:
|
|
payload = {
|
|
"resource_id": str(resource_id),
|
|
"created_at": created_at.isoformat(),
|
|
"item_id": str(item_id),
|
|
}
|
|
raw = json.dumps(payload, separators=(",", ":")).encode("utf-8")
|
|
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
|
|
|
|
|
|
def decode_cursor(cursor: Optional[str], expected_resource_id: UUID) -> Optional[Tuple[datetime, UUID]]:
|
|
if cursor is None:
|
|
return None
|
|
try:
|
|
padding = "=" * (-len(cursor) % 4)
|
|
raw = base64.urlsafe_b64decode(cursor + padding)
|
|
payload = json.loads(raw.decode("utf-8"))
|
|
resource_id = UUID(payload["resource_id"])
|
|
created_at = datetime.fromisoformat(payload["created_at"])
|
|
item_id = UUID(payload["item_id"])
|
|
if created_at.tzinfo is None or created_at.utcoffset() is None:
|
|
raise ValueError("invalid_cursor")
|
|
except (ValueError, KeyError, TypeError, AttributeError, json.JSONDecodeError):
|
|
raise bad_request("Invalid cursor")
|
|
if resource_id != expected_resource_id:
|
|
raise bad_request("Invalid cursor")
|
|
return created_at, item_id
|
|
|
|
|
|
# health
|
|
|
|
@app.get("/health/live", response_model=Dict[str, str])
|
|
def liveness() -> Dict[str, str]:
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.get("/health/ready", response_model=Dict[str, str])
|
|
def readiness(request: Request) -> Dict[str, str]:
|
|
# Критична только PostgreSQL. Redis — кэш с обходом, его отказ не делает
|
|
# API неготовым (см. REPORT.md).
|
|
try:
|
|
storage_of(request).ping()
|
|
except (psycopg.Error, PoolTimeout):
|
|
raise ApiError(503, "unavailable", "Database is not available")
|
|
return {"status": "ok"}
|
|
|
|
|
|
# users
|
|
|
|
@app.post("/api/v1/users", response_model=User, status_code=201)
|
|
def register_user(request: Request, data: UserCreate) -> User:
|
|
require_json_content_type(request)
|
|
ensure_not_blank(data.display_name)
|
|
ensure_not_blank(data.password)
|
|
password_hash = hash_password(data.password)
|
|
try:
|
|
return storage_of(request).create_user(data.username, data.display_name, password_hash)
|
|
except UsernameTaken:
|
|
raise ApiError(409, "conflict", "Username already exists")
|
|
|
|
|
|
@app.get("/api/v1/users/me", response_model=User)
|
|
def get_current_user(user: User = Depends(current_user)) -> User:
|
|
return user
|
|
|
|
|
|
# sessions
|
|
|
|
async def require_empty_body(request: Request) -> None:
|
|
"""Вход — только заголовок Authorization: Basic, без тела (контракт).
|
|
|
|
Любые байты в теле (JSON или нет) — 400. Проверка выполняется до
|
|
дорогой проверки пароля и до создания сессии.
|
|
"""
|
|
if await request.body():
|
|
raise bad_request("Request body is not allowed")
|
|
|
|
|
|
@app.post("/api/v1/auth/sessions", response_model=Session, status_code=201,
|
|
dependencies=[Depends(require_empty_body)])
|
|
def create_session(request: Request) -> Session:
|
|
credentials = parse_basic(request.headers.get("Authorization"))
|
|
if credentials is None:
|
|
raise unauthorized(BASIC_CHALLENGE)
|
|
username, password = credentials
|
|
found = storage_of(request).get_credentials(username)
|
|
user, password_hash = found if found else (None, None)
|
|
# verify_password выполняется и для несуществующего username (с хешем-пустышкой).
|
|
if not verify_password(password_hash, password) or user is None:
|
|
raise unauthorized(BASIC_CHALLENGE)
|
|
token, expires_at = request.app.state.sessions.create(user)
|
|
return Session(token=token, token_type="Bearer", expires_at=expires_at, user=user)
|
|
|
|
|
|
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
|
def delete_current_session(request: Request, user: User = Depends(current_user)) -> Response:
|
|
if not request.app.state.sessions.revoke(request.state.token):
|
|
raise unauthorized()
|
|
return Response(status_code=204)
|
|
|
|
|
|
# chats
|
|
|
|
@app.post("/api/v1/chats", response_model=Chat, status_code=201)
|
|
def create_chat(request: Request, data: ChatCreate, user: User = Depends(current_user)) -> Chat:
|
|
require_json_content_type(request)
|
|
ensure_not_blank(data.title)
|
|
if len(data.member_ids) != len(set(data.member_ids)):
|
|
raise bad_request("Duplicate member ids")
|
|
if user.id not in data.member_ids:
|
|
raise bad_request("Caller must be a chat member")
|
|
try:
|
|
return storage_of(request).create_chat(data.title, data.member_ids)
|
|
except UnknownMember:
|
|
raise bad_request("Unknown member")
|
|
|
|
|
|
@app.get("/api/v1/chats", response_model=ChatPage)
|
|
def list_chats(
|
|
request: Request,
|
|
user: User = Depends(current_user),
|
|
limit: int = Query(default=50, ge=1, le=100),
|
|
cursor: Optional[str] = Query(default=None, min_length=1),
|
|
) -> ChatPage:
|
|
after = decode_cursor(cursor, user.id)
|
|
items, has_more = storage_of(request).list_user_chats(user.id, limit, after)
|
|
next_cursor = None
|
|
if has_more and items:
|
|
next_cursor = encode_cursor(user.id, items[-1].created_at, items[-1].id)
|
|
return ChatPage(items=items, next_cursor=next_cursor)
|
|
|
|
|
|
@app.get("/api/v1/chats/{chat_id}", response_model=Chat)
|
|
def get_chat(request: Request, chat_id: UUID, user: User = Depends(current_user)) -> Chat:
|
|
chat = storage_of(request).get_chat_for_member(chat_id, user.id)
|
|
if chat is None:
|
|
raise not_found()
|
|
return chat
|
|
|
|
|
|
# messages
|
|
|
|
@app.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201)
|
|
def create_message(
|
|
request: Request,
|
|
chat_id: UUID,
|
|
data: MessageCreate,
|
|
user: User = Depends(current_user),
|
|
) -> Message:
|
|
require_json_content_type(request)
|
|
ensure_not_blank(data.text)
|
|
message = storage_of(request).create_message(chat_id, user.id, data.text)
|
|
if message is None:
|
|
raise not_found()
|
|
return message
|
|
|
|
|
|
@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
|
|
def list_messages(
|
|
request: Request,
|
|
chat_id: UUID,
|
|
user: User = Depends(current_user),
|
|
limit: int = Query(default=50, ge=1, le=100),
|
|
cursor: Optional[str] = Query(default=None, min_length=1),
|
|
) -> MessagePage:
|
|
after = decode_cursor(cursor, chat_id)
|
|
result = storage_of(request).list_messages(chat_id, user.id, limit, after)
|
|
if result is None:
|
|
raise not_found()
|
|
items, has_more = result
|
|
next_cursor = None
|
|
if has_more and items:
|
|
next_cursor = encode_cursor(chat_id, items[-1].created_at, items[-1].id)
|
|
return MessagePage(items=items, next_cursor=next_cursor)
|