رسیدگی به خطای زنگ زدگی: یک راهنمای کامل برای ساختن برنامه های قابل اعتماد [2024]

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

#[derive(Debug)]
pub enum DatabaseError {
    ConnectionFailed(String),
    QueryFailed(String),
    PoolExhausted,
}

impl fmt::Display for DatabaseError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::ConnectionFailed(msg) => write!(f, "Failed to connect: {}", msg),
            Self::QueryFailed(msg) => write!(f, "Query execution failed: {}", msg),
            Self::PoolExhausted => write!(f, "Connection pool exhausted"),
        }
    }
}

impl Error for DatabaseError {}

#[derive(Debug)]
pub enum ServiceError {
    Database(DatabaseError),
    Validation(String),
    Configuration(String),
}

impl fmt::Display for ServiceError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::Database(e) => write!(f, "Database error: {}", e),
            Self::Validation(msg) => write!(f, "Validation error: {}", msg),
            Self::Configuration(msg) => write!(f, "Configuration error: {}", msg),
        }
    }
}

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

impl From<DatabaseError> for ServiceError {
    fn from(err: DatabaseError) -> Self {
        ServiceError::Database(err)
    }
}

struct User {
    id: i32,
    name: String,
}

struct UserService {
    db_pool: Pool,
}

impl UserService {
    pub async fn create_user(&self, name: String) -> Result<User, ServiceError> {
        if name.is_empty() {
            return Err(ServiceError::Validation("Name cannot be empty".into()));
        }

        let conn = self.db_pool
            .get()
            .await
            .map_err(|e| DatabaseError::PoolExhausted)?;

        let user = conn.execute("INSERT INTO users (name) VALUES ($1)", &[&name])
            .await
            .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;

        Ok(user)
    }
}

use thiserror::Error;

#[derive(Error, Debug)]
pub enum ApiError {
    #[error("Authentication failed: {0}")]
    AuthError(String),

    #[error("Resource not found: {0}")]
    NotFound(String),

    #[error("Invalid input: {0}")]
    ValidationError(String),

    #[error(transparent)]
    DatabaseError(#[from] DatabaseError),
}

fn handle_request() -> Result<(), ApiError> {
    let token = validate_token()
        .map_err(|e| ApiError::AuthError(e.to_string()))?;

    let user = fetch_user(token)
        .map_err(|e| ApiError::NotFound("User not found".into()))?;

    Ok(())
}

use anyhow::{Context, Result};

fn process_config() -> Result<Config> {
    let config_path = std::env::var("CONFIG_PATH")
        .context("CONFIG_PATH environment variable not set")?;

    let config_file = std::fs::read_to_string(&config_path)
        .with_context(|| format!("Failed to read config file: {}", config_path))?;

    let config: Config = serde_json::from_str(&config_file)
        .context("Failed to parse config file")?;

    Ok(config)
}

#[derive(Debug)]
enum RetryableError {
    Temporary(String),
    Permanent(String),
}

impl RetryableError {
    fn is_retryable(&self) -> bool {
        matches!(self, Self::Temporary(_))
    }
}

async fn retry_operation<F, T, E>(
    mut operation: F,
    max_attempts: u32,
) -> Result<T, E>
where
    F: FnMut() -> Future<Output = Result<T, RetryableError>>,
    E: From<RetryableError>,
{
    let mut attempts = 0;
    loop {
        match operation().await {
            Ok(value) => return Ok(value),
            Err(e) if e.is_retryable() && attempts < max_attempts => {
                attempts += 1;
                continue;
            }
            Err(e) => return Err(e.into()),
        }
    }
}

use slog::{Logger, info, error, o};

fn log_error(logger: &Logger, err: &ServiceError) {
    match err {
        ServiceError::Database(db_err) => {
            error!(logger, "Database operation failed";
                "error" => %db_err,
                "error_type" => "database",
            );
        }
        ServiceError::Validation(msg) => {
            error!(logger, "Validation failed";
                "message" => msg,
                "error_type" => "validation",
            );
        }
        ServiceError::Configuration(msg) => {
            error!(logger, "Configuration error";
                "message" => msg,
                "error_type" => "config",
            );
        }
    }
}

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

    #[test]
    fn test_error_conversion() {
        let db_error = DatabaseError::ConnectionFailed("timeout".into());
        let service_error: ServiceError = db_error.into();

        assert!(matches!(service_error, ServiceError::Database(_)));
    }

    #[test]
    fn test_error_display() {
        let error = ServiceError::Validation("Invalid input".into());
        assert_eq!(
            error.to_string(),
            "Validation error: Invalid input"
        );
    }
}