591 lines
20 KiB
Python
591 lines
20 KiB
Python
import os
|
||
import subprocess
|
||
from app.repositories.neo4j.create_indexes import create_all_indexes
|
||
from contextlib import asynccontextmanager
|
||
|
||
from fastapi import FastAPI, APIRouter
|
||
from fastapi import HTTPException, Request
|
||
from fastapi.middleware.cors import CORSMiddleware
|
||
from fastapi.responses import JSONResponse
|
||
|
||
# 管理端 API (JWT 认证)
|
||
from app.controllers import manager_router
|
||
# 服务端 API (API Key 认证)
|
||
from app.controllers.service import service_router
|
||
from app.core.config import settings
|
||
from app.core.error_codes import BizCode, HTTP_MAPPING
|
||
from app.core.exceptions import BusinessException
|
||
from app.core.logging_config import LoggingConfig, get_logger
|
||
from app.core.response_utils import fail
|
||
from app.core.models.scripts.loader import load_models
|
||
from app.db import get_db_context
|
||
|
||
# Initialize logging system
|
||
LoggingConfig.setup_logging()
|
||
logger = get_logger(__name__)
|
||
|
||
|
||
@asynccontextmanager
|
||
async def lifespan(app: FastAPI):
|
||
"""使用 FastAPI lifespan 替代 on_event 处理启动/关闭事件"""
|
||
# 应用启动事件
|
||
|
||
# 检查是否需要自动升级数据库
|
||
if settings.DB_AUTO_UPGRADE:
|
||
logger.info("开始自动升级数据库...")
|
||
try:
|
||
result = subprocess.run(
|
||
["alembic", "upgrade", "head"],
|
||
capture_output=True,
|
||
text=True,
|
||
check=True
|
||
)
|
||
logger.info(f"数据库升级成功: {result.stdout}")
|
||
except subprocess.CalledProcessError as e:
|
||
logger.error(f"数据库升级失败: {e.stderr}")
|
||
raise RuntimeError(f"数据库升级失败: {e.stderr}")
|
||
except Exception as e:
|
||
logger.error(f"运行数据库升级时出错: {str(e)}")
|
||
raise
|
||
else:
|
||
logger.info("自动数据库升级已禁用 (DB_AUTO_UPGRADE=false)")
|
||
|
||
# 加载预定义模型
|
||
if settings.LOAD_MODEL:
|
||
logger.info("开始加载预定义模型...")
|
||
try:
|
||
with get_db_context() as db:
|
||
result = load_models(db, silent=True)
|
||
logger.info(f"预定义模型加载完成: 成功{result['success']}个, 跳过{result['skipped']}个, 失败{result['failed']}个")
|
||
except Exception as e:
|
||
logger.warning(f"加载预定义模型时出错: {str(e)}")
|
||
else:
|
||
logger.info("预定义模型加载已禁用 (LOAD_MODEL=false)")
|
||
await create_all_indexes()
|
||
logger.info("应用程序启动完成")
|
||
|
||
|
||
yield
|
||
# 应用关闭事件
|
||
logger.info("应用程序正在关闭")
|
||
|
||
|
||
app = FastAPI(
|
||
title="redbera-mem",
|
||
description="redbera-mem",
|
||
version="1.0.0",
|
||
lifespan=lifespan,
|
||
)
|
||
|
||
# Enable CORS for frontend access with environment-extendable origins
|
||
default_origins = [
|
||
settings.WEB_URL
|
||
]
|
||
allowed_origins = list({o for o in (default_origins + settings.CORS_ORIGINS) if o})
|
||
|
||
# 如果 CORS_ORIGINS 包含 "*"，则允许所有来源
|
||
if "*" in settings.CORS_ORIGINS:
|
||
allowed_origins = ["*"]
|
||
|
||
app.add_middleware(
|
||
CORSMiddleware,
|
||
allow_origins=allowed_origins,
|
||
allow_credentials=True if "*" not in allowed_origins else False, # 允许所有来源时不能使用 credentials
|
||
allow_methods=["*"],
|
||
allow_headers=["*"],
|
||
)
|
||
|
||
# Add i18n language detection middleware
|
||
from app.i18n.middleware import LanguageMiddleware
|
||
app.add_middleware(LanguageMiddleware)
|
||
|
||
logger.info("FastAPI应用程序启动")
|
||
|
||
|
||
@app.get("/", tags=["General"])
|
||
def read_root():
|
||
"""
|
||
A simple health check endpoint.
|
||
"""
|
||
logger.debug("健康检查端点被访问")
|
||
return {"message": "FastAPI is running"}
|
||
|
||
|
||
# 生命周期事件由 lifespan 管理，无需 on_event
|
||
|
||
|
||
# 注册路由
|
||
# 管理端 API (JWT 认证)
|
||
app.include_router(manager_router, prefix="/api")
|
||
|
||
# 服务端 API (API Key 认证)
|
||
app.include_router(service_router, prefix="/v1")
|
||
|
||
logger.info("所有路由已注册完成")
|
||
|
||
# Import additional exception types for specific handling
|
||
from app.core.exceptions import (
|
||
ValidationException,
|
||
ResourceNotFoundException,
|
||
PermissionDeniedException,
|
||
AuthenticationException,
|
||
AuthorizationException,
|
||
FileUploadException,
|
||
RateLimitException
|
||
)
|
||
from app.core.sensitive_filter import SensitiveDataFilter
|
||
import traceback
|
||
|
||
# Import i18n exception support
|
||
from app.i18n.exceptions import I18nException
|
||
from app.i18n.service import get_translation_service
|
||
from pydantic import ValidationError as PydanticValidationError
|
||
|
||
|
||
# 处理验证异常
|
||
@app.exception_handler(ValidationException)
|
||
async def validation_exception_handler(request: Request, exc: ValidationException):
|
||
"""处理验证异常"""
|
||
# 过滤敏感信息
|
||
filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context)
|
||
|
||
logger.warning(
|
||
f"Validation error: {filtered_message}",
|
||
extra={
|
||
"path": request.url.path,
|
||
"method": request.method,
|
||
"context": filtered_context,
|
||
"error_code": exc.code.value if isinstance(exc.code, BizCode) else exc.code,
|
||
"cause": str(exc.cause) if exc.cause else None
|
||
},
|
||
exc_info=exc.cause is not None
|
||
)
|
||
biz_code = exc.code if isinstance(exc.code, BizCode) else BizCode.VALIDATION_FAILED
|
||
status_code = HTTP_MAPPING.get(biz_code, 400)
|
||
return JSONResponse(
|
||
status_code=status_code,
|
||
content=fail(code=biz_code.value, msg=filtered_message, error=filtered_message)
|
||
)
|
||
|
||
|
||
# 处理 i18n 异常（国际化异常）
|
||
@app.exception_handler(I18nException)
|
||
async def i18n_exception_handler(request: Request, exc: I18nException):
|
||
"""
|
||
处理国际化异常
|
||
|
||
I18nException 已经自动翻译了错误消息，直接返回即可
|
||
"""
|
||
# 获取当前语言
|
||
language = getattr(request.state, "language", settings.I18N_DEFAULT_LANGUAGE)
|
||
|
||
# 获取异常详情（已经包含翻译后的消息）
|
||
detail = exc.detail
|
||
|
||
# 过滤敏感信息
|
||
if isinstance(detail, dict):
|
||
filtered_message = SensitiveDataFilter.filter_string(detail.get("message", ""))
|
||
filtered_detail = {
|
||
**detail,
|
||
"message": filtered_message
|
||
}
|
||
else:
|
||
filtered_detail = SensitiveDataFilter.filter_string(str(detail))
|
||
|
||
logger.warning(
|
||
f"I18n exception: {exc.error_key}",
|
||
extra={
|
||
"path": request.url.path,
|
||
"method": request.method,
|
||
"error_code": exc.error_code,
|
||
"error_key": exc.error_key,
|
||
"language": language,
|
||
"status_code": exc.status_code,
|
||
"params": exc.params
|
||
}
|
||
)
|
||
|
||
return JSONResponse(
|
||
status_code=exc.status_code,
|
||
content={
|
||
"success": False,
|
||
**filtered_detail
|
||
},
|
||
headers=exc.headers
|
||
)
|
||
|
||
|
||
# 处理 Pydantic 验证错误（国际化支持）
|
||
@app.exception_handler(PydanticValidationError)
|
||
async def pydantic_validation_exception_handler(request: Request, exc: PydanticValidationError):
|
||
"""
|
||
处理 Pydantic 验证错误，支持国际化
|
||
"""
|
||
# 获取当前语言
|
||
language = getattr(request.state, "language", settings.I18N_DEFAULT_LANGUAGE)
|
||
|
||
# 获取翻译服务
|
||
translation_service = get_translation_service()
|
||
|
||
# 翻译验证错误消息
|
||
errors = []
|
||
for error in exc.errors():
|
||
field = ".".join(str(loc) for loc in error["loc"])
|
||
error_type = error["type"]
|
||
|
||
# 尝试翻译错误消息
|
||
if error_type == "value_error.missing":
|
||
message = translation_service.translate(
|
||
"errors.validation.missing_field",
|
||
language,
|
||
field=field
|
||
)
|
||
elif error_type == "value_error.any_str.max_length":
|
||
message = translation_service.translate(
|
||
"errors.validation.field_too_long",
|
||
language,
|
||
field=field
|
||
)
|
||
elif error_type == "value_error.any_str.min_length":
|
||
message = translation_service.translate(
|
||
"errors.validation.field_too_short",
|
||
language,
|
||
field=field
|
||
)
|
||
else:
|
||
# 使用通用验证错误消息
|
||
message = translation_service.translate(
|
||
"errors.validation.invalid_field",
|
||
language,
|
||
field=field
|
||
)
|
||
|
||
errors.append({
|
||
"field": field,
|
||
"message": message,
|
||
"type": error_type
|
||
})
|
||
|
||
# 翻译主错误消息
|
||
main_message = translation_service.translate(
|
||
"errors.common.validation_failed",
|
||
language
|
||
)
|
||
|
||
logger.warning(
|
||
f"Pydantic validation error: {len(errors)} errors",
|
||
extra={
|
||
"path": request.url.path,
|
||
"method": request.method,
|
||
"language": language,
|
||
"errors": errors
|
||
}
|
||
)
|
||
|
||
return JSONResponse(
|
||
status_code=422,
|
||
content={
|
||
"success": False,
|
||
"error_code": "VALIDATION_FAILED",
|
||
"message": main_message,
|
||
"errors": errors
|
||
}
|
||
)
|
||
|
||
|
||
# 处理资源不存在异常
|
||
@app.exception_handler(ResourceNotFoundException)
|
||
async def not_found_exception_handler(request: Request, exc: ResourceNotFoundException):
|
||
"""处理资源不存在异常"""
|
||
# 过滤敏感信息
|
||
filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context)
|
||
|
||
logger.info(
|
||
f"Resource not found: {filtered_message}",
|
||
extra={
|
||
"path": request.url.path,
|
||
"method": request.method,
|
||
"context": filtered_context,
|
||
"error_code": exc.code.value if isinstance(exc.code, BizCode) else exc.code,
|
||
"cause": str(exc.cause) if exc.cause else None
|
||
}
|
||
)
|
||
biz_code = exc.code if isinstance(exc.code, BizCode) else BizCode.FILE_NOT_FOUND
|
||
status_code = HTTP_MAPPING.get(biz_code, 404)
|
||
return JSONResponse(
|
||
status_code=status_code,
|
||
content=fail(code=biz_code.value, msg=filtered_message, error=filtered_message)
|
||
)
|
||
|
||
|
||
# 处理权限拒绝异常
|
||
@app.exception_handler(PermissionDeniedException)
|
||
async def permission_denied_handler(request: Request, exc: PermissionDeniedException):
|
||
"""处理权限拒绝异常"""
|
||
# 过滤敏感信息
|
||
filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context)
|
||
|
||
logger.warning(
|
||
f"Permission denied: {filtered_message}",
|
||
extra={
|
||
"path": request.url.path,
|
||
"method": request.method,
|
||
"user": getattr(request.state, "user_id", None),
|
||
"context": filtered_context,
|
||
"error_code": exc.code.value if isinstance(exc.code, BizCode) else exc.code,
|
||
"cause": str(exc.cause) if exc.cause else None
|
||
}
|
||
)
|
||
biz_code = exc.code if isinstance(exc.code, BizCode) else BizCode.FORBIDDEN
|
||
status_code = HTTP_MAPPING.get(biz_code, 403)
|
||
return JSONResponse(
|
||
status_code=status_code,
|
||
content=fail(code=biz_code.value, msg=filtered_message, error=filtered_message)
|
||
)
|
||
|
||
|
||
# 处理认证异常
|
||
@app.exception_handler(AuthenticationException)
|
||
async def authentication_exception_handler(request: Request, exc: AuthenticationException):
|
||
"""处理认证异常"""
|
||
# 过滤敏感信息
|
||
filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context)
|
||
|
||
logger.warning(
|
||
f"Authentication error: {filtered_message}",
|
||
extra={
|
||
"path": request.url.path,
|
||
"method": request.method,
|
||
"context": filtered_context,
|
||
"error_code": exc.code.value if isinstance(exc.code, BizCode) else exc.code,
|
||
"cause": str(exc.cause) if exc.cause else None
|
||
}
|
||
)
|
||
biz_code = exc.code if isinstance(exc.code, BizCode) else BizCode.UNAUTHORIZED
|
||
status_code = HTTP_MAPPING.get(biz_code, 401)
|
||
return JSONResponse(
|
||
status_code=status_code,
|
||
content=fail(code=biz_code.value, msg=filtered_message, error=filtered_message)
|
||
)
|
||
|
||
|
||
# 处理授权异常
|
||
@app.exception_handler(AuthorizationException)
|
||
async def authorization_exception_handler(request: Request, exc: AuthorizationException):
|
||
"""处理授权异常"""
|
||
# 过滤敏感信息
|
||
filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context)
|
||
|
||
logger.warning(
|
||
f"Authorization error: {filtered_message}",
|
||
extra={
|
||
"path": request.url.path,
|
||
"method": request.method,
|
||
"context": filtered_context,
|
||
"error_code": exc.code.value if isinstance(exc.code, BizCode) else exc.code,
|
||
"cause": str(exc.cause) if exc.cause else None
|
||
}
|
||
)
|
||
biz_code = exc.code if isinstance(exc.code, BizCode) else BizCode.FORBIDDEN
|
||
status_code = HTTP_MAPPING.get(biz_code, 403)
|
||
return JSONResponse(
|
||
status_code=status_code,
|
||
content=fail(code=biz_code.value, msg=filtered_message, error=filtered_message)
|
||
)
|
||
|
||
|
||
# 处理文件上传异常
|
||
@app.exception_handler(FileUploadException)
|
||
async def file_upload_exception_handler(request: Request, exc: FileUploadException):
|
||
"""处理文件上传异常"""
|
||
# 过滤敏感信息
|
||
filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context)
|
||
|
||
logger.error(
|
||
f"File upload error: {filtered_message}",
|
||
extra={
|
||
"path": request.url.path,
|
||
"method": request.method,
|
||
"context": filtered_context,
|
||
"error_code": exc.code.value if isinstance(exc.code, BizCode) else exc.code,
|
||
"cause": str(exc.cause) if exc.cause else None
|
||
},
|
||
exc_info=exc.cause is not None
|
||
)
|
||
biz_code = exc.code if isinstance(exc.code, BizCode) else BizCode.FILE_READ_ERROR
|
||
status_code = HTTP_MAPPING.get(biz_code, 500)
|
||
return JSONResponse(
|
||
status_code=status_code,
|
||
content=fail(code=biz_code.value, msg=filtered_message, error=filtered_message)
|
||
)
|
||
|
||
|
||
# 处理限流异常
|
||
@app.exception_handler(RateLimitException)
|
||
async def rate_limit_exception_handler(request: Request, exc: RateLimitException):
|
||
"""处理限流异常"""
|
||
# 过滤敏感信息
|
||
filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context)
|
||
|
||
logger.warning(
|
||
f"Rate limit exceeded: {filtered_message}",
|
||
extra={
|
||
"path": request.url.path,
|
||
"method": request.method,
|
||
"context": filtered_context,
|
||
"error_code": exc.code.value if isinstance(exc.code, BizCode) else exc.code,
|
||
"cause": str(exc.cause) if exc.cause else None
|
||
}
|
||
)
|
||
|
||
biz_code = exc.code if isinstance(exc.code, BizCode) else BizCode.RATE_LIMITED
|
||
status_code = HTTP_MAPPING.get(biz_code, 429)
|
||
|
||
# 创建响应对象并添加限流头信息
|
||
response = JSONResponse(
|
||
status_code=status_code,
|
||
content=fail(code=biz_code.value, msg=filtered_message, error=filtered_message)
|
||
)
|
||
|
||
# 添加限流相关的响应头
|
||
rate_headers = exc.context.get("rate_limit_headers", {}) if exc.context else {}
|
||
for header_name, header_value in rate_headers.items():
|
||
response.headers[header_name] = str(header_value)
|
||
|
||
return response
|
||
|
||
|
||
# 业务异常统一处理（使用业务错误码）
|
||
@app.exception_handler(BusinessException)
|
||
async def business_exception_handler(request: Request, exc: BusinessException):
|
||
"""处理通用业务异常"""
|
||
# 过滤敏感信息
|
||
filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context)
|
||
|
||
logger.error(
|
||
f"Business error: {filtered_message}",
|
||
extra={
|
||
"path": request.url.path,
|
||
"method": request.method,
|
||
"context": filtered_context,
|
||
"error_code": exc.code.value if isinstance(exc.code, BizCode) else exc.code,
|
||
"cause": str(exc.cause) if exc.cause else None
|
||
},
|
||
exc_info=exc.cause is not None
|
||
)
|
||
raw_code = exc.code
|
||
if isinstance(raw_code, BizCode):
|
||
biz_code = raw_code
|
||
elif isinstance(raw_code, int):
|
||
try:
|
||
biz_code = BizCode(raw_code)
|
||
except ValueError:
|
||
biz_code = BizCode.BAD_REQUEST
|
||
else:
|
||
biz_code = BizCode.BAD_REQUEST
|
||
|
||
status_code = HTTP_MAPPING.get(biz_code, 400)
|
||
return JSONResponse(
|
||
status_code=status_code,
|
||
content=fail(code=biz_code.value, msg=filtered_message, error=filtered_message)
|
||
)
|
||
|
||
|
||
# 统一异常处理：将HTTPException转换为统一响应结构（支持国际化）
|
||
@app.exception_handler(HTTPException)
|
||
async def http_exception_handler(request: Request, exc: HTTPException):
|
||
"""处理HTTP异常，支持国际化"""
|
||
# 获取当前语言
|
||
language = getattr(request.state, "language", settings.I18N_DEFAULT_LANGUAGE)
|
||
|
||
# 获取翻译服务
|
||
translation_service = get_translation_service()
|
||
|
||
# 尝试翻译标准HTTP错误
|
||
error_key_map = {
|
||
400: "errors.common.bad_request",
|
||
401: "errors.common.unauthorized",
|
||
403: "errors.common.forbidden",
|
||
404: "errors.common.not_found",
|
||
405: "errors.common.method_not_allowed",
|
||
409: "errors.common.conflict",
|
||
413: "errors.common.payload_too_large",
|
||
422: "errors.common.validation_failed",
|
||
429: "errors.common.too_many_requests",
|
||
500: "errors.common.internal_error",
|
||
502: "errors.common.bad_gateway",
|
||
503: "errors.common.service_unavailable",
|
||
504: "errors.common.gateway_timeout",
|
||
}
|
||
|
||
# 如果有对应的翻译键，使用翻译
|
||
if exc.status_code in error_key_map:
|
||
translated_message = translation_service.translate(
|
||
error_key_map[exc.status_code],
|
||
language
|
||
)
|
||
else:
|
||
# 否则过滤原始消息
|
||
translated_message = SensitiveDataFilter.filter_string(str(exc.detail))
|
||
|
||
logger.warning(
|
||
f"HTTP exception: {translated_message}",
|
||
extra={
|
||
"path": request.url.path,
|
||
"method": request.method,
|
||
"status_code": exc.status_code,
|
||
"language": language
|
||
}
|
||
)
|
||
|
||
return JSONResponse(
|
||
status_code=exc.status_code,
|
||
content=fail(code=exc.status_code, msg=translated_message, error=exc.detail)
|
||
)
|
||
|
||
|
||
# 捕获未处理的异常，返回统一错误结构（支持国际化）
|
||
@app.exception_handler(Exception)
|
||
async def unhandled_exception_handler(request: Request, exc: Exception):
|
||
"""处理未捕获的异常，支持国际化"""
|
||
# 获取当前语言
|
||
language = getattr(request.state, "language", settings.I18N_DEFAULT_LANGUAGE)
|
||
|
||
# 获取翻译服务
|
||
translation_service = get_translation_service()
|
||
|
||
# 记录完整的堆栈跟踪（日志过滤器会自动过滤敏感信息）
|
||
logger.error(
|
||
f"Unhandled exception: {exc}",
|
||
extra={
|
||
"path": request.url.path,
|
||
"method": request.method,
|
||
"exception_type": type(exc).__name__,
|
||
"language": language,
|
||
"traceback": traceback.format_exc()
|
||
},
|
||
exc_info=True
|
||
)
|
||
|
||
# 生产环境隐藏详细错误信息
|
||
environment = os.getenv("ENVIRONMENT", "development")
|
||
if environment == "production":
|
||
# 使用翻译的通用错误消息
|
||
message = translation_service.translate(
|
||
"errors.common.internal_error",
|
||
language
|
||
)
|
||
else:
|
||
# 开发环境也要过滤敏感信息
|
||
message = SensitiveDataFilter.filter_string(str(exc))
|
||
|
||
return JSONResponse(
|
||
status_code=500,
|
||
content=fail(code=BizCode.INTERNAL_ERROR.value, msg=message, error=message)
|
||
)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
import uvicorn
|
||
uvicorn.run(app, host="0.0.0.0", port=8000)
|