433 lines
14 KiB
Rust
433 lines
14 KiB
Rust
use thiserror::Error;
|
|
|
|
/// 应用错误类型
|
|
#[derive(Error, Debug, Clone)]
|
|
pub enum AppError {
|
|
/// 配置错误
|
|
#[error("{0}")]
|
|
Config(String),
|
|
|
|
/// 文件操作错误
|
|
#[error("{0}")]
|
|
File(String),
|
|
|
|
/// 格式不支持错误
|
|
#[error("{0}")]
|
|
UnsupportedFormat(String),
|
|
|
|
/// 解析错误
|
|
#[error("{0}")]
|
|
Parse(String),
|
|
|
|
/// MinerU错误
|
|
#[error("{0}")]
|
|
MinerU(String),
|
|
|
|
/// MarkItDown错误
|
|
#[error("{0}")]
|
|
MarkItDown(String),
|
|
|
|
/// OSS操作错误
|
|
#[error("{0}")]
|
|
Oss(String),
|
|
|
|
/// 数据库错误
|
|
#[error("{0}")]
|
|
Database(String),
|
|
|
|
/// 网络错误
|
|
#[error("{0}")]
|
|
Network(String),
|
|
|
|
/// 任务错误
|
|
#[error("{0}")]
|
|
Task(String),
|
|
|
|
/// 内部错误
|
|
#[error("{0}")]
|
|
Internal(String),
|
|
|
|
/// 超时错误
|
|
#[error("{0}")]
|
|
Timeout(String),
|
|
|
|
/// 验证错误
|
|
#[error("{0}")]
|
|
Validation(String),
|
|
|
|
/// 环境错误
|
|
#[error("{0}")]
|
|
Environment(String),
|
|
|
|
/// 虚拟环境路径错误
|
|
#[error("{0}")]
|
|
VirtualEnvironmentPath(String),
|
|
|
|
/// 权限错误
|
|
#[error("{0}")]
|
|
Permission(String),
|
|
|
|
/// 路径错误
|
|
#[error("{0}")]
|
|
Path(String),
|
|
|
|
/// 队列错误
|
|
#[error("{0}")]
|
|
Queue(String),
|
|
|
|
/// 处理错误
|
|
#[error("{0}")]
|
|
Processing(String),
|
|
}
|
|
|
|
impl AppError {
|
|
// ===========================================
|
|
// 工厂方法 - 创建带国际化消息的错误
|
|
// ===========================================
|
|
|
|
/// 创建配置错误
|
|
pub fn config_error(detail: impl Into<String>) -> Self {
|
|
Self::Config(t!("errors.document_parser.config", detail = detail.into()).to_string())
|
|
}
|
|
|
|
/// 创建文件操作错误
|
|
pub fn file_error(detail: impl Into<String>) -> Self {
|
|
Self::File(t!("errors.document_parser.file", detail = detail.into()).to_string())
|
|
}
|
|
|
|
/// 创建格式不支持错误
|
|
pub fn unsupported_format(format: impl Into<String>) -> Self {
|
|
Self::UnsupportedFormat(
|
|
t!(
|
|
"errors.document_parser.unsupported_format",
|
|
format = format.into()
|
|
)
|
|
.to_string(),
|
|
)
|
|
}
|
|
|
|
/// 创建解析错误
|
|
pub fn parse_error(detail: impl Into<String>) -> Self {
|
|
Self::Parse(t!("errors.document_parser.parse", detail = detail.into()).to_string())
|
|
}
|
|
|
|
/// 创建 MinerU 错误
|
|
pub fn mineru_error(detail: impl Into<String>) -> Self {
|
|
Self::MinerU(t!("errors.document_parser.mineru", detail = detail.into()).to_string())
|
|
}
|
|
|
|
/// 创建 MarkItDown 错误
|
|
pub fn markitdown_error(detail: impl Into<String>) -> Self {
|
|
Self::MarkItDown(
|
|
t!("errors.document_parser.markitdown", detail = detail.into()).to_string(),
|
|
)
|
|
}
|
|
|
|
/// 创建 OSS 错误
|
|
pub fn oss_error(detail: impl Into<String>) -> Self {
|
|
Self::Oss(t!("errors.document_parser.oss", detail = detail.into()).to_string())
|
|
}
|
|
|
|
/// 创建数据库错误
|
|
pub fn database_error(detail: impl Into<String>) -> Self {
|
|
Self::Database(t!("errors.document_parser.database", detail = detail.into()).to_string())
|
|
}
|
|
|
|
/// 创建网络错误
|
|
pub fn network_error(detail: impl Into<String>) -> Self {
|
|
Self::Network(t!("errors.document_parser.network", detail = detail.into()).to_string())
|
|
}
|
|
|
|
/// 创建任务错误
|
|
pub fn task_error(detail: impl Into<String>) -> Self {
|
|
Self::Task(t!("errors.document_parser.task", detail = detail.into()).to_string())
|
|
}
|
|
|
|
/// 创建内部错误
|
|
pub fn internal_error(detail: impl Into<String>) -> Self {
|
|
Self::Internal(t!("errors.document_parser.internal", detail = detail.into()).to_string())
|
|
}
|
|
|
|
/// 创建超时错误
|
|
pub fn timeout_error(detail: impl Into<String>) -> Self {
|
|
Self::Timeout(t!("errors.document_parser.timeout", detail = detail.into()).to_string())
|
|
}
|
|
|
|
/// 创建验证错误
|
|
pub fn validation_error(detail: impl Into<String>) -> Self {
|
|
Self::Validation(
|
|
t!("errors.document_parser.validation", detail = detail.into()).to_string(),
|
|
)
|
|
}
|
|
|
|
/// 创建环境错误
|
|
pub fn environment_error(detail: impl Into<String>) -> Self {
|
|
Self::Environment(
|
|
t!("errors.document_parser.environment", detail = detail.into()).to_string(),
|
|
)
|
|
}
|
|
|
|
/// 创建虚拟环境路径错误
|
|
pub fn virtual_environment_path_error(message: String, path: &std::path::Path) -> Self {
|
|
let path_str = path.display().to_string();
|
|
Self::VirtualEnvironmentPath(
|
|
t!(
|
|
"errors.document_parser.virtual_environment_path",
|
|
detail = format!("{} (path: {})", message, path_str)
|
|
)
|
|
.to_string(),
|
|
)
|
|
}
|
|
|
|
/// 创建权限错误
|
|
pub fn permission_error(message: String, path: &std::path::Path) -> Self {
|
|
let path_str = path.display().to_string();
|
|
Self::Permission(
|
|
t!(
|
|
"errors.document_parser.permission",
|
|
detail = format!("{} (path: {})", message, path_str)
|
|
)
|
|
.to_string(),
|
|
)
|
|
}
|
|
|
|
/// 创建路径错误
|
|
pub fn path_error(message: String, path: &std::path::Path) -> Self {
|
|
let path_str = path.display().to_string();
|
|
Self::Path(
|
|
t!(
|
|
"errors.document_parser.path",
|
|
detail = format!("{} (path: {})", message, path_str)
|
|
)
|
|
.to_string(),
|
|
)
|
|
}
|
|
|
|
/// 创建队列错误
|
|
pub fn queue_error(detail: impl Into<String>) -> Self {
|
|
Self::Queue(t!("errors.document_parser.queue", detail = detail.into()).to_string())
|
|
}
|
|
|
|
/// 创建处理错误
|
|
pub fn processing_error(detail: impl Into<String>) -> Self {
|
|
Self::Processing(
|
|
t!("errors.document_parser.processing", detail = detail.into()).to_string(),
|
|
)
|
|
}
|
|
|
|
/// 获取路径相关错误的详细恢复建议
|
|
pub fn get_path_recovery_suggestions(&self) -> Vec<String> {
|
|
match self {
|
|
AppError::VirtualEnvironmentPath(msg) => {
|
|
let mut suggestions = vec![
|
|
"检查当前目录是否有写入权限".to_string(),
|
|
"确保当前目录下没有名为 'venv' 的文件（非目录）".to_string(),
|
|
"尝试删除损坏的虚拟环境目录: rm -rf ./venv".to_string(),
|
|
"检查磁盘空间是否充足".to_string(),
|
|
];
|
|
|
|
if msg.contains("权限") || msg.contains("permission") {
|
|
suggestions.insert(0, "使用 sudo 或管理员权限运行命令".to_string());
|
|
suggestions.push("检查目录所有者和权限: ls -la".to_string());
|
|
}
|
|
|
|
if msg.contains("存在") || msg.contains("exists") {
|
|
suggestions.push("备份现有虚拟环境后重新创建".to_string());
|
|
}
|
|
|
|
suggestions
|
|
}
|
|
AppError::Permission(_msg) => {
|
|
let mut suggestions = vec![
|
|
"检查文件和目录权限设置".to_string(),
|
|
"确保当前用户有足够的权限".to_string(),
|
|
];
|
|
|
|
if cfg!(unix) {
|
|
suggestions.extend(vec![
|
|
"使用 chmod 修改权限: chmod 755 <目录>".to_string(),
|
|
"使用 chown 修改所有者: chown $USER <目录>".to_string(),
|
|
"检查 SELinux 或 AppArmor 安全策略".to_string(),
|
|
]);
|
|
} else if cfg!(windows) {
|
|
suggestions.extend(vec![
|
|
"以管理员身份运行命令提示符".to_string(),
|
|
"检查 Windows 用户账户控制 (UAC) 设置".to_string(),
|
|
"确保目录不在受保护的系统路径中".to_string(),
|
|
]);
|
|
}
|
|
|
|
suggestions
|
|
}
|
|
AppError::Path(msg) => {
|
|
let mut suggestions = vec![
|
|
"检查路径是否正确拼写".to_string(),
|
|
"确保路径存在且可访问".to_string(),
|
|
"检查路径中是否包含特殊字符".to_string(),
|
|
];
|
|
|
|
if msg.contains("不存在") || msg.contains("not found") {
|
|
suggestions.push("创建缺失的目录结构".to_string());
|
|
}
|
|
|
|
if msg.contains("长度") || msg.contains("length") {
|
|
suggestions.push("使用较短的路径名称".to_string());
|
|
}
|
|
|
|
suggestions
|
|
}
|
|
_ => vec!["检查系统环境和配置".to_string()],
|
|
}
|
|
}
|
|
|
|
/// 获取错误代码
|
|
pub fn get_error_code(&self) -> &'static str {
|
|
match self {
|
|
AppError::Config(_) => "E001",
|
|
AppError::File(_) => "E002",
|
|
AppError::UnsupportedFormat(_) => "E003",
|
|
AppError::Parse(_) => "E004",
|
|
AppError::MinerU(_) => "E005",
|
|
AppError::MarkItDown(_) => "E006",
|
|
AppError::Oss(_) => "E007",
|
|
AppError::Database(_) => "E008",
|
|
AppError::Network(_) => "E009",
|
|
AppError::Task(_) => "E010",
|
|
AppError::Internal(_) => "E011",
|
|
AppError::Timeout(_) => "E012",
|
|
AppError::Validation(_) => "E013",
|
|
AppError::Environment(_) => "E014",
|
|
AppError::Queue(_) => "E015",
|
|
AppError::Processing(_) => "E016",
|
|
AppError::VirtualEnvironmentPath(_) => "E017",
|
|
AppError::Permission(_) => "E018",
|
|
AppError::Path(_) => "E019",
|
|
}
|
|
}
|
|
|
|
/// 获取错误建议（国际化）
|
|
pub fn get_suggestion(&self) -> String {
|
|
match self {
|
|
AppError::Config(_) => t!("errors.document_parser.suggestions.config").to_string(),
|
|
AppError::File(_) => t!("errors.document_parser.suggestions.file").to_string(),
|
|
AppError::UnsupportedFormat(_) => {
|
|
t!("errors.document_parser.suggestions.unsupported_format").to_string()
|
|
}
|
|
AppError::Parse(_) => t!("errors.document_parser.suggestions.parse").to_string(),
|
|
AppError::MinerU(_) => t!("errors.document_parser.suggestions.mineru").to_string(),
|
|
AppError::MarkItDown(_) => {
|
|
t!("errors.document_parser.suggestions.markitdown").to_string()
|
|
}
|
|
AppError::Oss(_) => t!("errors.document_parser.suggestions.oss").to_string(),
|
|
AppError::Database(_) => t!("errors.document_parser.suggestions.database").to_string(),
|
|
AppError::Network(_) => t!("errors.document_parser.suggestions.network").to_string(),
|
|
AppError::Task(_) => t!("errors.document_parser.suggestions.task").to_string(),
|
|
AppError::Internal(_) => t!("errors.document_parser.suggestions.internal").to_string(),
|
|
AppError::Timeout(_) => t!("errors.document_parser.suggestions.timeout").to_string(),
|
|
AppError::Validation(_) => {
|
|
t!("errors.document_parser.suggestions.validation").to_string()
|
|
}
|
|
AppError::Environment(_) => {
|
|
t!("errors.document_parser.suggestions.environment").to_string()
|
|
}
|
|
AppError::Queue(_) => t!("errors.document_parser.suggestions.queue").to_string(),
|
|
AppError::Processing(_) => {
|
|
t!("errors.document_parser.suggestions.processing").to_string()
|
|
}
|
|
AppError::VirtualEnvironmentPath(_) => {
|
|
t!("errors.document_parser.suggestions.virtual_environment_path").to_string()
|
|
}
|
|
AppError::Permission(_) => {
|
|
t!("errors.document_parser.suggestions.permission").to_string()
|
|
}
|
|
AppError::Path(_) => t!("errors.document_parser.suggestions.path").to_string(),
|
|
}
|
|
}
|
|
|
|
/// 转换为HTTP响应格式
|
|
pub fn to_http_result<T>(&self) -> crate::models::HttpResult<T> {
|
|
use crate::models::HttpResult;
|
|
|
|
HttpResult::<T>::error(
|
|
self.get_error_code().to_string(),
|
|
format!("{} - {}", self, self.get_suggestion()),
|
|
)
|
|
}
|
|
}
|
|
|
|
/// 从标准库错误转换
|
|
impl From<std::io::Error> for AppError {
|
|
fn from(err: std::io::Error) -> Self {
|
|
Self::file_error(err.to_string())
|
|
}
|
|
}
|
|
|
|
/// 从serde错误转换
|
|
impl From<serde_json::Error> for AppError {
|
|
fn from(err: serde_json::Error) -> Self {
|
|
Self::parse_error(format!("JSON: {err}"))
|
|
}
|
|
}
|
|
|
|
/// 从serde_yaml错误转换
|
|
impl From<serde_yaml::Error> for AppError {
|
|
fn from(err: serde_yaml::Error) -> Self {
|
|
Self::config_error(format!("YAML: {err}"))
|
|
}
|
|
}
|
|
|
|
/// 从sled错误转换
|
|
impl From<sled::Error> for AppError {
|
|
fn from(err: sled::Error) -> Self {
|
|
Self::database_error(format!("Sled: {err}"))
|
|
}
|
|
}
|
|
|
|
/// 从reqwest错误转换
|
|
impl From<reqwest::Error> for AppError {
|
|
fn from(err: reqwest::Error) -> Self {
|
|
if err.is_timeout() {
|
|
Self::timeout_error("HTTP request")
|
|
} else if err.is_connect() {
|
|
Self::network_error("connection failed")
|
|
} else {
|
|
Self::network_error(err.to_string())
|
|
}
|
|
}
|
|
}
|
|
|
|
/// 从anyhow错误转换
|
|
impl From<anyhow::Error> for AppError {
|
|
fn from(err: anyhow::Error) -> Self {
|
|
Self::internal_error(err.to_string())
|
|
}
|
|
}
|
|
|
|
/// 从std::env::VarError转换
|
|
impl From<std::env::VarError> for AppError {
|
|
fn from(err: std::env::VarError) -> Self {
|
|
Self::config_error(format!("environment variable: {err}"))
|
|
}
|
|
}
|
|
|
|
/// 从std::num::ParseIntError转换
|
|
impl From<std::num::ParseIntError> for AppError {
|
|
fn from(err: std::num::ParseIntError) -> Self {
|
|
Self::config_error(format!("integer parse: {err}"))
|
|
}
|
|
}
|
|
|
|
/// 从std::str::ParseBoolError转换
|
|
impl From<std::str::ParseBoolError> for AppError {
|
|
fn from(err: std::str::ParseBoolError) -> Self {
|
|
Self::config_error(format!("boolean parse: {err}"))
|
|
}
|
|
}
|
|
|
|
/// 从std::time::SystemTimeError转换
|
|
impl From<std::time::SystemTimeError> for AppError {
|
|
fn from(err: std::time::SystemTimeError) -> Self {
|
|
Self::internal_error(err.to_string())
|
|
}
|
|
}
|