🦀 Rust 错误处理深度指南

use std::panic;

let result = panic::catch_unwind(|| {
    println!("before panic");
    panic!("oh no!");
    println!("never reached");
});

match result {
    Ok(_) => println!("正常完成"),
    Err(_) => println!("捕获到 panic！"),
}

// 输出：
// before panic
// 捕获到 panic！

use std::fs;

// ❌ 嵌套 match —— 金字塔厄运
fn parse_config_v1(path: &str) -> Result<Config, AppError> {
    match fs::read_to_string(path) {
        Ok(content) => match toml::from_str(&content) {
            Ok(config) => Ok(config),
            Err(e) => Err(AppError::Parse(e)),
        },
        Err(e) => Err(AppError::Io(e)),
    }
}

// ✅ 组合子风格 —— 线性、可读
fn parse_config_v2(path: &str) -> Result<Config, AppError> {
    fs::read_to_string(path)
        .map_err(AppError::Io)
        .and_then(|content| {
            toml::from_str(&content)
                .map_err(AppError::Parse)
        })
}

// ✅ 好：解释了为什么这里不可能失败
let port: u16 = env::var("PORT")
    .expect("PORT must be set by the deployment script");

// ❌ 差：没有上下文
let port: u16 = env::var("PORT").unwrap();

// ✅ 测试中：随意 unwrap
#[test]
fn test_addition() {
    assert_eq!(parse("1+2").unwrap(), 3);
}

// 这一行：
let content = fs::read_to_string(path)?;

// 等价于：
let content = match fs::read_to_string(path) {
    Ok(v) => v,
    Err(e) => return Err(e.into()),
};

use std::fs;
use std::io;

// 无 ? 版本
fn read_and_parse(path: &str) -> Result<Config, io::Error> {
    let content = match fs::read_to_string(path) {
        Ok(c) => c,
        Err(e) => return Err(e),
    };
    let config = match parse(&content) {
        Ok(c) => c,
        Err(e) => return Err(e),
    };
    Ok(config)
}

// ? 链版本
fn read_and_parse(path: &str) -> Result<Config, io::Error> {
    let content = fs::read_to_string(path)?;
    let config = parse(&content)?;
    Ok(config)
}

// 甚至一行搞定
fn read_and_parse(path: &str) -> Result<Config, io::Error> {
    parse(&fs::read_to_string(path)?)
}

fn last_char_of_first_line(text: &str) -> Option<char> {
    let first_line = text.lines().next()?;  // None → return None
    first_line.chars().last()               // Some(c) or None
}

#![feature(try_blocks)]

fn try_operation() -> Result<i32, io::Error> {
    let result: Result<i32, io::Error> = try {
        let a = fs::read_to_string("a.txt")?;
        let b = fs::read_to_string("b.txt")?;
        a.len() + b.len()
    };
    result
}

// try 块让你在同一个函数中使用 ?
// 而不需要每个子函数都返回 Result

// 稳定版替代方案：闭包 + ?
let result = (|| -> Result<_, io::Error> {
    let a = fs::read_to_string("a.txt")?;
    let b = fs::read_to_string("b.txt")?;
    Ok(a.len() + b.len())
})();

// Option → Result
fn find_user(id: u64) -> Option<User> { ... }

// 需要给 None 一个有意义的错误
let user = find_user(42)
    .ok_or(AppError::UserNotFound(42))?;

// Result → Option（丢弃错误信息）
let maybe_port: Option<u16> = env::var("PORT")
    .ok()                    // Err → None
    .and_then(|s| s.parse().ok());  // ParseError → None

// ⚠️ ok() 丢弃了错误，只在"不关心错误原因"时使用

struct Config {
    database_url: Option<String>,
    pool_size: Option<usize>,
    timeout_secs: Option<u64>,
}

// 环境变量覆盖配置
fn resolve_pool_size(config: &Config) -> usize {
    env::var("DB_POOL_SIZE")
        .ok()
        .and_then(|s| s.parse().ok())
        .or(config.pool_size)
        .unwrap_or(10)  // 最终默认值
}

// filter：条件过滤
fn find_admin(users: &[User]) -> Option<&User> {
    users.iter()
        .find(|u| u.is_admin)
        .filter(|u| u.is_active)  // 找到 admin 且必须是 active
}

use std::fmt;
use std::error::Error;
use std::io;

#[derive(Debug)]
enum AppError {
    Io(io::Error),
    Config(String),
    Database(DbError),
    NotFound { resource: String, id: u64 },
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            AppError::Io(e) => write!(f, "IO error: {e}"),
            AppError::Config(msg) => write!(f, "Config error: {msg}"),
            AppError::Database(e) => write!(f, "Database error: {e}"),
            AppError::NotFound { resource, id } => {
                write!(f, "{resource} with id {id} not found")
            }
        }
    }
}

impl Error for AppError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            AppError::Io(e) => Some(e),
            AppError::Database(e) => Some(e),
            _ => None,
        }
    }
}

// 为每个子错误实现 From
impl From<io::Error> for AppError {
    fn from(e: io::Error) -> Self { AppError::Io(e) }
}

impl From<DbError> for AppError {
    fn from(e: DbError) -> Self { AppError::Database(e) }
}

use thiserror::Error;

#[derive(Error, Debug)]
enum AppError {
    #[error("IO error: {0}")]
    Io(#[from] io::Error),          // auto From + source

    #[error("Config error: {0}")]
    Config(String),

    #[error("Database error: {0}")]
    Database(#[from] DbError),      // auto From + source

    #[error("{resource} with id {id} not found")]
    NotFound { resource: String, id: u64 },
}

use error_set::error_set;

error_set! {
    AppError = {
        Io(std::io::Error),
        Config(String),
        Database(DbError),
        NotFound { resource: String, id: u64 },
    }
}

// error_set 自动生成：
// - Display / Error impls
// - From 转换
// - 错误子集（可以定义分层错误）
// - 比手写 thiserror 更少的样板

use std::error::Error;

fn print_error_chain(err: &dyn Error) {
    let mut source = Some(err);
    let mut depth = 0;
    while let Some(e) = source {
        println!("{}{}", "  ".repeat(depth), e);
        source = e.source();
        depth += 1;
    }
}

// 输出示例：
// Database error: connection refused
//   Connection error: tcp connect failed
//     IO error: Connection refused (os error 111)

use anyhow::{Context, Result, anyhow, bail};

fn read_config(path: &str) -> Result<Config> {
    let content = fs::read_to_string(path)
        .context(format!("Failed to read config from {path}"))?;

    let config: Config = toml::from_str(&content)
        .context("Failed to parse config")?;

    if config.pool_size == 0 {
        bail!("pool_size cannot be zero");
    }

    Ok(config)
}

// 顶层处理
fn main() -> anyhow::Result<()> {
    let config = read_config("config.toml")?;
    run_server(config)?;
    Ok(())
}
// main 返回 anyhow::Result 时，错误会自动打印到 stderr

use anyhow::{Context, Result};

fn process_order(order_id: u64) -> Result<Order> {
    let order = db::find_order(order_id)
        .context("Failed to fetch order from database")?;

    let user = db::find_user(order.user_id)
        .context("Failed to fetch order's user")?;

    let payment = payment::charge(&order, &user)
        .context(format!(
            "Payment failed for order {order_id}, user {}",
            user.name
        ))?;

    Ok(order)
}

// 错误输出示例：
// Payment failed for order 42, user Alice
//   Caused by:
//     0: Charge request failed
//     1: Connection refused (os error 111)

// context() 立即构造字符串——即使成功也要花时间
.context(format!("Failed to process order {order_id}"))?

// with_context() 仅在失败时才执行闭包
.with_context(|| format!("Failed to process order {order_id}"))?

// 推荐在字符串构造有开销时使用 with_context

// 1. Cargo.toml
[dependencies]
anyhow = { version = "1", features = ["backtrace"] }

// 2. 设置环境变量
// RUST_BACKTRACE=1

// 3. 错误中自动包含 backtrace
fn deep_function() -> Result<()> {
    Ok(fs::read_to_string("nonexistent")?)
}

// 错误输出包含完整调用栈：
// No such file or directory (os error 2)
// Stack backtrace:
//    0: anyhow::backtrace::capture::...
//    1: deep_function::...
//    2: main::...

// db-crate/src/error.rs
use thiserror::Error;

#[derive(Error, Debug)]
pub enum DbError {
    #[error("Connection to {host}:{port} failed: {source}")]
    ConnectionFailed {
        host: String,
        port: u16,
        source: sqlx::Error,
    },

    #[error("Query timeout after {ms}ms: {query}")]
    QueryTimeout { ms: u64, query: String },

    #[error("Record not found: {table}/{id}")]
    NotFound { table: String, id: String },

    #[error("Unique constraint violated: {constraint}")]
    UniqueViolation { constraint: String },

    #[error(transparent)]
    Internal(#[from] sqlx::Error),
}

// service-crate/src/error.rs
use thiserror::Error;

#[derive(Error, Debug)]
pub enum ServiceError {
    #[error("User {user_id} not found")]
    UserNotFound { user_id: u64 },

    #[error("Email already registered")]
    DuplicateEmail,

    #[error("Service temporarily unavailable")]
    Unavailable,

    #[error("Internal error")]
    Internal,  // 不暴露 DB 细节！
}

// 显式转换：DB 错误 → 服务错误
impl From<DbError> for ServiceError {
    fn from(e: DbError) -> Self {
        match e {
            DbError::NotFound { table, id } if table == "users" => {
                ServiceError::UserNotFound {
                    user_id: id.parse().unwrap_or(0),
                }
            }
            DbError::UniqueViolation { ref constraint }
                if constraint.contains("email") => {
                ServiceError::DuplicateEmail
            }
            DbError::ConnectionFailed { .. }
            | DbError::QueryTimeout { .. } => {
                ServiceError::Unavailable
            }
            _ => ServiceError::Internal,
        }
    }
}

// api-crate/src/error.rs
use axum::http::StatusCode;
use axum::response::{IntoResponse, Response};
use serde::Serialize;

#[derive(Serialize)]
struct ErrorResponse {
    error: ErrorBody,
}

#[derive(Serialize)]
struct ErrorBody {
    code: String,
    message: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    request_id: Option<String>,
}

impl IntoResponse for ServiceError {
    fn into_response(self) -> Response {
        let (status, code, message) = match &self {
            ServiceError::UserNotFound { .. } => (
                StatusCode::NOT_FOUND,
                "USER_NOT_FOUND",
                "The requested user does not exist",
            ),
            ServiceError::DuplicateEmail => (
                StatusCode::CONFLICT,
                "DUPLICATE_EMAIL",
                "This email is already registered",
            ),
            ServiceError::Unavailable => (
                StatusCode::SERVICE_UNAVAILABLE,
                "SERVICE_UNAVAILABLE",
                "Service is temporarily unavailable",
            ),
            ServiceError::Internal => (
                StatusCode::INTERNAL_SERVER_ERROR,
                "INTERNAL_ERROR",
                "An internal error occurred",
            ),
        };

        // 日志中记录完整错误，响应中只返回安全信息
        tracing::error!(error = %self, "Request failed");

        (status, axum::Json(ErrorResponse {
            error: ErrorBody {
                code: code.to_string(),
                message: message.to_string(),
                request_id: None,
            },
        })).into_response()
    }
}

use tokio::task::JoinError;

// 1. 任务 panic
let handle = tokio::spawn(async {
    panic!("task crashed!");
});
let result = handle.await;  // Result<T, JoinError>
match result {
    Ok(value) => println!("成功: {value:?}"),
    Err(e) if e.is_panic() => {
        // 任务内部 panic 了
        // 注意：panic 信息被包装了
        println!("任务 panic: {e}");
    }
    Err(e) if e.is_cancelled() => {
        println!("任务被取消");
    }
    Err(e) => println!("Join 错误: {e}"),
}

// 2. 任务被取消（JoinHandle::abort）
handle.abort();

use tokio::time::{timeout, Duration};
use anyhow::{Context, Result};

async fn fetch_with_timeout(url: &str) -> Result<String> {
    timeout(Duration::from_secs(5), reqwest::get(url))
        .await
        .context("Request timed out after 5 seconds")?   // ← ElapsedError
        .context(format!("Failed to fetch {url}"))?
        .text()
        .await
        .context("Failed to read response body")
}

// timeout 返回 Result<T, ElapsedError>
// ElapsedError 需要二次处理内层 Result

use tokio::select;
use tokio::sync::mpsc;

// ❌ 不安全：可能丢失消息
async fn process_unsafe(mut rx: mpsc::Receiver<Msg>) {
    // 如果 select! 走了 timeout 分支，
    // rx.recv() 返回的 Some(msg) 就丢了！
    select! {
        msg = rx.recv() => {
            // 处理 msg
        }
        _ = tokio::time::sleep(Duration::from_secs(30)) => {
            // 超时
        }
    }
}

// ✅ 安全：使用 cancellation-safe 模式
async fn process_safe(mut rx: mpsc::Receiver<Msg>) {
    select! {
        msg = rx.recv() => {
            // recv() 是 cancellation-safe 的：
            // 如果被 drop，消息留在 channel 中不丢失
        }
        _ = tokio::time::sleep(Duration::from_secs(30)) => {
            // 超时
        }
    }
}

// ⚠️ 哪些操作是 cancellation-safe 的？
// ✅ recv()   — 消息留在 channel
// ✅ read()   — 数据留在 buffer
// ❌ send()   — 消息可能已发送但未确认
// ❌ write()  — 数据可能部分写入

use tokio::select;

async fn multi_source() -> Result<Data> {
    let mut db_fut = db::fetch();
    let mut cache_fut = cache::fetch();
    let mut api_fut = api::fetch();

    // 任一成功就返回，全部失败才报错
    let mut errors = Vec::new();

    loop {
        select! {
            result = &mut db_fut => {
                match result {
                    Ok(data) => return Ok(data),
                    Err(e) => {
                        tracing::warn!("DB failed: {e}");
                        errors.push(e.into());
                    }
                }
            }
            result = &mut cache_fut => {
                match result {
                    Ok(data) => return Ok(data),
                    Err(e) => {
                        tracing::warn!("Cache failed: {e}");
                        errors.push(e.into());
                    }
                }
            }
            result = &mut api_fut => {
                match result {
                    Ok(data) => return Ok(data),
                    Err(e) => {
                        tracing::warn!("API failed: {e}");
                        errors.push(e.into());
                    }
                }
            }
        }

        if errors.len() == 3 {
            anyhow::bail!("All sources failed: {:?}", errors);
        }
    }
}

use sqlx::error::DatabaseError;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum DbError {
    #[error("Connection pool exhausted")]
    PoolExhausted,

    #[error("Record not found in {table}: {key}={value}")]
    NotFound {
        table: String,
        key: String,
        value: String,
    },

    #[error("Duplicate entry in {table}: {constraint}")]
    Duplicate {
        table: String,
        constraint: String,
    },

    #[error("Query timed out after {ms}ms")]
    Timeout { ms: u64 },

    #[error("Database operation failed")]
    Operational(#[source] sqlx::Error),
}

impl From<sqlx::Error> for DbError {
    fn from(e: sqlx::Error) -> Self {
        match &e {
            sqlx::Error::RowNotFound => DbError::Operational(e),
            sqlx::Error::PoolTimedOut => DbError::PoolExhausted,
            sqlx::Error::Database(db_err) => {
                // 解析 PostgreSQL 特定错误码
                // 23505 = unique_violation
                if db_err.code().map(|c| c == "23505").unwrap_or(false) {
                    DbError::Duplicate {
                        table: db_err.table()
                            .unwrap_or("unknown")
                            .to_string(),
                        constraint: db_err.constraint()
                            .unwrap_or("unknown")
                            .to_string(),
                    }
                } else {
                    DbError::Operational(e)
                }
            }
            _ => DbError::Operational(e),
        }
    }
}

// 数据库仓库方法
impl UserRepo {
    pub async fn find_by_id(&self, id: u64) -> Result<UserRow, DbError> {
        sqlx::query_as!(
            UserRow,
            "SELECT * FROM users WHERE id = $1",
            id as i64
        )
        .fetch_one(&self.pool)
        .await
        .map_err(|e| match e {
            sqlx::Error::RowNotFound => DbError::NotFound {
                table: "users".into(),
                key: "id".into(),
                value: id.to_string(),
            },
            other => other.into(),
        })
    }

    pub async fn create(&self, user: NewUser) -> Result<UserRow, DbError> {
        sqlx::query_as!(
            UserRow,
            "INSERT INTO users (email, name) VALUES ($1, $2)
             RETURNING *",
            user.email, user.name
        )
        .fetch_one(&self.pool)
        .await
        .map_err(Into::into)  // sqlx::Error → DbError
    }
}

use thiserror::Error;
use crate::db::DbError;

#[derive(Error, Debug)]
pub enum ServiceError {
    // 业务领域错误——用领域语言表达
    #[error("User {id} not found")]
    UserNotFound { id: u64 },

    #[error("Email {email} already registered")]
    DuplicateEmail { email: String },

    #[error("Invalid email format: {email}")]
    InvalidEmail { email: String },

    #[error("Cannot delete user {id}: has active orders")]
    UserHasOrders { id: u64 },

    // 基础设施故障——对业务屏蔽细节
    #[error("Service temporarily unavailable")]
    Unavailable,

    #[error("Internal error")]
    Internal,
}

// 关键：显式转换，不泄露 DB 细节
impl From<DbError> for ServiceError {
    fn from(e: DbError) -> Self {
        match e {
            DbError::NotFound { table, value, .. }
                if table == "users" =>
            {
                ServiceError::UserNotFound {
                    id: value.parse().unwrap_or(0),
                }
            }
            DbError::Duplicate { constraint, .. }
                if constraint.contains("email") =>
            {
                // 我们没有 email 信息——需要调用者提供
                ServiceError::DuplicateEmail {
                    email: "unknown".into(),
                }
            }
            DbError::PoolExhausted | DbError::Timeout { .. } => {
                ServiceError::Unavailable
            }
            _ => ServiceError::Internal,
        }
    }
}

// 服务实现
impl UserService {
    pub async fn get_user(&self, id: u64) -> Result<User, ServiceError> {
        let row = self.repo.find_by_id(id).await?;
        Ok(User::from(row))
    }

    pub async fn create_user(
        &self,
        email: String,
        name: String,
    ) -> Result<User, ServiceError> {
        // 业务验证
        if !email.contains('@') {
            return Err(ServiceError::InvalidEmail { email });
        }

        let row = self.repo
            .create(NewUser { email: email.clone(), name })
            .await
            .map_err(|e| match e {
                DbError::Duplicate { constraint, .. }
                    if constraint.contains("email") =>
                {
                    ServiceError::DuplicateEmail { email }
                }
                other => other.into(),
            })?;

        Ok(User::from(row))
    }
}

use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    Json,
};
use serde::Serialize;
use service::ServiceError;
use uuid::Uuid;

#[derive(Debug)]
pub struct ApiError {
    inner: ServiceError,
    request_id: Uuid,
}

impl ApiError {
    pub fn new(inner: ServiceError, request_id: Uuid) -> Self {
        Self { inner, request_id }
    }
}

#[derive(Serialize)]
struct ErrorBody {
    code: String,
    message: String,
    request_id: String,
}

impl IntoResponse for ApiError {
    fn into_response(self) -> Response {
        let (status, code, message) = match &self.inner {
            ServiceError::UserNotFound { .. } => (
                StatusCode::NOT_FOUND,
                "USER_NOT_FOUND",
                "The requested user does not exist",
            ),
            ServiceError::DuplicateEmail { .. } => (
                StatusCode::CONFLICT,
                "DUPLICATE_EMAIL",
                "This email address is already registered",
            ),
            ServiceError::InvalidEmail { .. } => (
                StatusCode::BAD_REQUEST,
                "INVALID_EMAIL",
                "Please provide a valid email address",
            ),
            ServiceError::UserHasOrders { .. } => (
                StatusCode::CONFLICT,
                "USER_HAS_ORDERS",
                "Cannot delete user with active orders",
            ),
            ServiceError::Unavailable => (
                StatusCode::SERVICE_UNAVAILABLE,
                "SERVICE_UNAVAILABLE",
                "Please try again later",
            ),
            ServiceError::Internal => (
                StatusCode::INTERNAL_SERVER_ERROR,
                "INTERNAL_ERROR",
                "An unexpected error occurred",
            ),
        };

        // 📝 日志中记录完整信息（包括 source chain）
        tracing::error!(
            error = %self.inner,
            error_chain = ?self.inner,
            request_id = %self.request_id,
            status = %status.as_u16(),
            "Request failed"
        );

        // 🔒 响应中只返回安全信息
        (status, Json(ErrorBody {
            code: code.to_string(),
            message: message.to_string(),
            request_id: self.request_id.to_string(),
        })).into_response()
    }
}

// Handler 中使用
async fn get_user(
    State(state): State<AppState>,
    Path(id): Path<u64>,
) -> Result<Json<User>, ApiError> {
    let request_id = Uuid::new_v4();

    state.service
        .get_user(id)
        .await
        .map_err(|e| ApiError::new(e, request_id))
        .map(Json)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn db_not_found_to_service_user_not_found() {
        let db_err = DbError::NotFound {
            table: "users".into(),
            key: "id".into(),
            value: "42".into(),
        };
        let svc_err: ServiceError = db_err.into();
        assert!(matches!(
            svc_err,
            ServiceError::UserNotFound { id: 42 }
        ));
    }

    #[test]
    fn db_duplicate_email_to_service() {
        let db_err = DbError::Duplicate {
            table: "users".into(),
            constraint: "users_email_key".into(),
        };
        let svc_err: ServiceError = db_err.into();
        assert!(matches!(svc_err, ServiceError::DuplicateEmail { .. }));
    }

    #[test]
    fn db_pool_exhausted_to_unavailable() {
        let db_err = DbError::PoolExhausted;
        let svc_err: ServiceError = db_err.into();
        assert!(matches!(svc_err, ServiceError::Unavailable));
    }

    #[tokio::test]
    async fn api_error_response_format() {
        let svc_err = ServiceError::UserNotFound { id: 42 };
        let api_err = ApiError::new(svc_err, Uuid::nil());

        let response = api_err.into_response();
        assert_eq!(response.status(), 404);
    }
}