forked from mtusi2026/mtusi2026lab5
261 lines
8.0 KiB
Python
261 lines
8.0 KiB
Python
import asyncio
|
|
import logging
|
|
import uuid
|
|
|
|
import asyncpg
|
|
import botocore.exceptions
|
|
from fastapi import FastAPI, Request, status
|
|
from fastapi.exceptions import RequestValidationError
|
|
from fastapi.responses import JSONResponse
|
|
import redis.exceptions
|
|
from starlette.exceptions import HTTPException as StarletteHTTPException
|
|
|
|
from app.config import INSTANCE_ID
|
|
from app.schemas import ErrorCode, ErrorDetail, ErrorResponse
|
|
|
|
|
|
class StorageError(Exception):
|
|
pass
|
|
|
|
|
|
class UnavailableError(StorageError):
|
|
pass
|
|
|
|
|
|
class InvalidRequestError(StorageError):
|
|
pass
|
|
|
|
|
|
class NotFoundError(StorageError):
|
|
pass
|
|
|
|
|
|
class ConflictError(StorageError):
|
|
pass
|
|
|
|
|
|
class PayloadTooLargeError(StorageError):
|
|
pass
|
|
|
|
|
|
class UnsupportedMediaTypeError(StorageError):
|
|
pass
|
|
|
|
|
|
class UnauthorizedError(StorageError):
|
|
pass
|
|
|
|
|
|
logger = logging.getLogger("app.errors")
|
|
|
|
|
|
def get_request_id(request: Request) -> str:
|
|
req_id = getattr(request.state, "request_id", None)
|
|
if not req_id:
|
|
req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
|
|
return req_id
|
|
|
|
|
|
def make_error_response(
|
|
status_code: int,
|
|
code: ErrorCode,
|
|
message: str,
|
|
request_id: str,
|
|
headers: dict[str, str] | None = None,
|
|
) -> JSONResponse:
|
|
payload = ErrorResponse(
|
|
error=ErrorDetail(code=code, message=message, request_id=request_id)
|
|
).model_dump()
|
|
resp_headers = {
|
|
"X-Request-Id": request_id,
|
|
"X-Instance-Id": INSTANCE_ID,
|
|
"Content-Type": "application/json",
|
|
}
|
|
if headers:
|
|
resp_headers.update(headers)
|
|
return JSONResponse(
|
|
status_code=status_code,
|
|
content=payload,
|
|
headers=resp_headers,
|
|
)
|
|
|
|
|
|
def register_error_handlers(app: FastAPI) -> None:
|
|
@app.exception_handler(InvalidRequestError)
|
|
async def invalid_request_handler(
|
|
request: Request, exc: InvalidRequestError
|
|
) -> JSONResponse:
|
|
req_id = get_request_id(request)
|
|
return make_error_response(
|
|
status.HTTP_400_BAD_REQUEST, ErrorCode.INVALID_REQUEST, str(exc), req_id
|
|
)
|
|
|
|
@app.exception_handler(UnauthorizedError)
|
|
async def unauthorized_handler(
|
|
request: Request, exc: UnauthorizedError
|
|
) -> JSONResponse:
|
|
req_id = get_request_id(request)
|
|
scheme = (
|
|
'Basic realm="messenger", charset="UTF-8"'
|
|
if request.url.path == "/api/v1/auth/sessions"
|
|
else 'Bearer realm="messenger"'
|
|
)
|
|
return make_error_response(
|
|
status.HTTP_401_UNAUTHORIZED,
|
|
ErrorCode.UNAUTHORIZED,
|
|
str(exc),
|
|
req_id,
|
|
headers={"WWW-Authenticate": scheme},
|
|
)
|
|
|
|
@app.exception_handler(NotFoundError)
|
|
async def not_found_handler(request: Request, exc: NotFoundError) -> JSONResponse:
|
|
req_id = get_request_id(request)
|
|
return make_error_response(
|
|
status.HTTP_404_NOT_FOUND, ErrorCode.NOT_FOUND, str(exc), req_id
|
|
)
|
|
|
|
@app.exception_handler(ConflictError)
|
|
async def conflict_handler(request: Request, exc: ConflictError) -> JSONResponse:
|
|
req_id = get_request_id(request)
|
|
return make_error_response(
|
|
status.HTTP_409_CONFLICT, ErrorCode.CONFLICT, str(exc), req_id
|
|
)
|
|
|
|
@app.exception_handler(PayloadTooLargeError)
|
|
async def payload_too_large_handler(
|
|
request: Request, exc: PayloadTooLargeError
|
|
) -> JSONResponse:
|
|
req_id = get_request_id(request)
|
|
return make_error_response(
|
|
status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
|
|
ErrorCode.PAYLOAD_TOO_LARGE,
|
|
str(exc),
|
|
req_id,
|
|
)
|
|
|
|
@app.exception_handler(UnsupportedMediaTypeError)
|
|
async def unsupported_media_type_handler(
|
|
request: Request, exc: UnsupportedMediaTypeError
|
|
) -> JSONResponse:
|
|
req_id = get_request_id(request)
|
|
return make_error_response(
|
|
status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
|
|
ErrorCode.UNSUPPORTED_MEDIA_TYPE,
|
|
str(exc),
|
|
req_id,
|
|
)
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def validation_error_handler(
|
|
request: Request, exc: RequestValidationError
|
|
) -> JSONResponse:
|
|
req_id = get_request_id(request)
|
|
errors = exc.errors()
|
|
messages = []
|
|
for err in errors:
|
|
loc = ".".join(str(x) for x in err.get("loc", []) if x != "body")
|
|
msg = err.get("msg", "invalid")
|
|
messages.append(f"{loc}: {msg}" if loc else msg)
|
|
detail_msg = "; ".join(messages) or "Некорректное тело запроса или параметры"
|
|
return make_error_response(
|
|
status.HTTP_400_BAD_REQUEST, ErrorCode.INVALID_REQUEST, detail_msg, req_id
|
|
)
|
|
|
|
@app.exception_handler(StarletteHTTPException)
|
|
async def http_exception_handler(
|
|
request: Request, exc: StarletteHTTPException
|
|
) -> JSONResponse:
|
|
req_id = get_request_id(request)
|
|
code = ErrorCode.INTERNAL_ERROR
|
|
extra_headers: dict[str, str] = {}
|
|
if exc.status_code == 400:
|
|
code = ErrorCode.INVALID_REQUEST
|
|
elif exc.status_code == 401:
|
|
code = ErrorCode.UNAUTHORIZED
|
|
scheme = (
|
|
'Basic realm="messenger", charset="UTF-8"'
|
|
if request.url.path == "/api/v1/auth/sessions"
|
|
else 'Bearer realm="messenger"'
|
|
)
|
|
extra_headers["WWW-Authenticate"] = scheme
|
|
elif exc.status_code == 404:
|
|
code = ErrorCode.NOT_FOUND
|
|
elif exc.status_code == 409:
|
|
code = ErrorCode.CONFLICT
|
|
elif exc.status_code == 413:
|
|
code = ErrorCode.PAYLOAD_TOO_LARGE
|
|
elif exc.status_code == 415:
|
|
code = ErrorCode.UNSUPPORTED_MEDIA_TYPE
|
|
elif exc.status_code == 429:
|
|
code = ErrorCode.RATE_LIMITED
|
|
elif exc.status_code == 503:
|
|
code = ErrorCode.UNAVAILABLE
|
|
|
|
msg = exc.detail if isinstance(exc.detail, str) else "HTTP ошибка"
|
|
return make_error_response(
|
|
exc.status_code, code, msg, req_id, headers=extra_headers
|
|
)
|
|
|
|
async def dependency_unavailable_handler(
|
|
request: Request, exc: Exception
|
|
) -> JSONResponse:
|
|
req_id = get_request_id(request)
|
|
logger.warning(
|
|
"Upstream storage dependency unavailable for request %s: %s",
|
|
req_id,
|
|
exc,
|
|
)
|
|
return make_error_response(
|
|
status.HTTP_503_SERVICE_UNAVAILABLE,
|
|
ErrorCode.UNAVAILABLE,
|
|
"Зависимость недоступна",
|
|
req_id,
|
|
)
|
|
|
|
for exc_cls in (
|
|
UnavailableError,
|
|
asyncpg.PostgresError,
|
|
asyncpg.InterfaceError,
|
|
redis.exceptions.RedisError,
|
|
botocore.exceptions.BotoCoreError,
|
|
botocore.exceptions.ClientError,
|
|
TimeoutError,
|
|
asyncio.TimeoutError,
|
|
ConnectionError,
|
|
OSError,
|
|
):
|
|
app.add_exception_handler(exc_cls, dependency_unavailable_handler)
|
|
|
|
@app.exception_handler(Exception)
|
|
async def unhandled_exception_handler(
|
|
request: Request, exc: Exception
|
|
) -> JSONResponse:
|
|
req_id = get_request_id(request)
|
|
if isinstance(
|
|
exc,
|
|
(
|
|
UnavailableError,
|
|
asyncpg.PostgresError,
|
|
asyncpg.InterfaceError,
|
|
redis.exceptions.RedisError,
|
|
botocore.exceptions.BotoCoreError,
|
|
botocore.exceptions.ClientError,
|
|
TimeoutError,
|
|
asyncio.TimeoutError,
|
|
ConnectionError,
|
|
OSError,
|
|
),
|
|
):
|
|
return await dependency_unavailable_handler(request, exc)
|
|
|
|
logger.error(
|
|
"Unhandled exception for request %s: %s", req_id, exc, exc_info=True
|
|
)
|
|
return make_error_response(
|
|
status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
ErrorCode.INTERNAL_ERROR,
|
|
"Внутренняя ошибка сервера",
|
|
req_id,
|
|
)
|