Refactor trusted-proxies: modernize utils, improve safety, and fix clippy lints (#1693)

Co-authored-by: majinghe <42570491+majinghe@users.noreply.github.com>
Co-authored-by: GatewayJ <835269233@qq.com>
Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>
Co-authored-by: houseme <4829346+houseme@users.noreply.github.com>
Co-authored-by: heihutu <30542132+heihutu@users.noreply.github.com>

crates/trusted-proxies/src/error/config.rs

@@ -0,0 +1,82 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Configuration error types for the trusted proxy system.
+
+use std::net::AddrParseError;
+
+/// Errors related to application configuration.
+#[derive(Debug, thiserror::Error)]
+pub enum ConfigError {
+    /// Required environment variable is missing.
+    #[error("Missing environment variable: {0}")]
+    MissingEnvVar(String),
+
+    /// Environment variable exists but could not be parsed.
+    #[error("Failed to parse environment variable {0}: {1}")]
+    EnvParseError(String, String),
+
+    /// A configuration value is logically invalid.
+    #[error("Invalid configuration value for {0}: {1}")]
+    InvalidValue(String, String),
+
+    /// An IP address or CIDR range is malformed.
+    #[error("Invalid IP address or network: {0}")]
+    InvalidIp(String),
+
+    /// Configuration failed overall validation.
+    #[error("Configuration validation failed: {0}")]
+    ValidationFailed(String),
+
+    /// Two or more configuration settings are in conflict.
+    #[error("Configuration conflict: {0}")]
+    Conflict(String),
+
+    /// Error reading or parsing a configuration file.
+    #[error("Config file error: {0}")]
+    FileError(String),
+
+    /// General invalid configuration error.
+    #[error("Invalid config: {0}")]
+    InvalidConfig(String),
+}
+
+impl From<AddrParseError> for ConfigError {
+    fn from(err: AddrParseError) -> Self {
+        Self::InvalidIp(err.to_string())
+    }
+}
+
+impl From<ipnetwork::IpNetworkError> for ConfigError {
+    fn from(err: ipnetwork::IpNetworkError) -> Self {
+        Self::InvalidIp(err.to_string())
+    }
+}
+
+impl ConfigError {
+    /// Creates a `MissingEnvVar` error.
+    pub fn missing_env_var(key: &str) -> Self {
+        Self::MissingEnvVar(key.to_string())
+    }
+
+    /// Creates an `EnvParseError`.
+    pub fn env_parse(key: &str, value: &str) -> Self {
+        Self::EnvParseError(key.to_string(), value.to_string())
+    }
+
+    /// Creates an `InvalidValue` error.
+    pub fn invalid_value(field: &str, value: &str) -> Self {
+        Self::InvalidValue(field.to_string(), value.to_string())
+    }
+}

crates/trusted-proxies/src/error/mod.rs

@@ -0,0 +1,94 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Error types for the trusted proxy system.
+
+mod config;
+mod proxy;
+
+pub use config::*;
+pub use proxy::*;
+
+/// Unified error type for the application.
+#[derive(Debug, thiserror::Error)]
+pub enum AppError {
+    /// Errors related to configuration.
+    #[error("Configuration error: {0}")]
+    Config(#[from] ConfigError),
+
+    /// Errors related to proxy validation.
+    #[error("Proxy validation error: {0}")]
+    Proxy(#[from] ProxyError),
+
+    /// Errors related to cloud service integration.
+    #[error("Cloud service error: {0}")]
+    Cloud(String),
+
+    /// General internal errors.
+    #[error("Internal error: {0}")]
+    Internal(String),
+
+    /// Standard I/O errors.
+    #[error("IO error: {0}")]
+    Io(#[from] std::io::Error),
+
+    /// Errors related to HTTP requests or responses.
+    #[error("HTTP error: {0}")]
+    Http(String),
+}
+
+impl AppError {
+    /// Creates a new `Cloud` error.
+    pub fn cloud(msg: impl Into<String>) -> Self {
+        Self::Cloud(msg.into())
+    }
+
+    /// Creates a new `Internal` error.
+    pub fn internal(msg: impl Into<String>) -> Self {
+        Self::Internal(msg.into())
+    }
+
+    /// Creates a new `Http` error.
+    pub fn http(msg: impl Into<String>) -> Self {
+        Self::Http(msg.into())
+    }
+
+    /// Returns true if the error is considered recoverable.
+    pub fn is_recoverable(&self) -> bool {
+        match self {
+            Self::Config(_) => true,
+            Self::Proxy(e) => e.is_recoverable(),
+            Self::Cloud(_) => true,
+            Self::Internal(_) => false,
+            Self::Io(_) => true,
+            Self::Http(_) => true,
+        }
+    }
+}
+
+/// Type alias for API error responses (Status Code, Error Message).
+pub type ApiError = (http::StatusCode, String);
+
+impl From<AppError> for ApiError {
+    fn from(err: AppError) -> Self {
+        match err {
+            AppError::Config(_) => (http::StatusCode::BAD_REQUEST, err.to_string()),
+            AppError::Proxy(_) => (http::StatusCode::BAD_REQUEST, err.to_string()),
+            AppError::Cloud(_) => (http::StatusCode::SERVICE_UNAVAILABLE, err.to_string()),
+            AppError::Internal(_) => (http::StatusCode::INTERNAL_SERVER_ERROR, err.to_string()),
+            AppError::Io(_) => (http::StatusCode::INTERNAL_SERVER_ERROR, err.to_string()),
+            AppError::Http(_) => (http::StatusCode::BAD_GATEWAY, err.to_string()),
+        }
+    }
+}

crates/trusted-proxies/src/error/proxy.rs

@@ -0,0 +1,114 @@
+// Copyright 2024 RustFS Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Proxy validation error types for the trusted proxy system.
+
+use std::net::AddrParseError;
+
+/// Errors that can occur during proxy chain validation.
+#[derive(Debug, thiserror::Error)]
+pub enum ProxyError {
+    /// The X-Forwarded-For header is malformed or contains invalid data.
+    #[error("Invalid X-Forwarded-For header: {0}")]
+    InvalidXForwardedFor(String),
+
+    /// The RFC 7239 Forwarded header is malformed.
+    #[error("Invalid Forwarded header (RFC 7239): {0}")]
+    InvalidForwardedHeader(String),
+
+    /// General failure during proxy chain validation.
+    #[error("Proxy chain validation failed: {0}")]
+    ChainValidationFailed(String),
+
+    /// The number of proxy hops exceeds the configured limit.
+    #[error("Proxy chain too long: {0} hops (max: {1})")]
+    ChainTooLong(usize, usize),
+
+    /// The request originated from a proxy that is not in the trusted list.
+    #[error("Request from untrusted proxy: {0}")]
+    UntrustedProxy(String),
+
+    /// The proxy chain is not continuous (e.g., an untrusted IP is between trusted ones).
+    #[error("Proxy chain is not continuous")]
+    ChainNotContinuous,
+
+    /// An IP address in the chain could not be parsed.
+    #[error("Failed to parse IP address: {0}")]
+    IpParseError(String),
+
+    /// A header value could not be parsed as a string.
+    #[error("Failed to parse header: {0}")]
+    HeaderParseError(String),
+
+    /// Validation took too long and timed out.
+    #[error("Validation timeout")]
+    Timeout,
+
+    /// An unexpected internal error occurred during validation.
+    #[error("Internal validation error: {0}")]
+    Internal(String),
+}
+
+impl From<AddrParseError> for ProxyError {
+    fn from(err: AddrParseError) -> Self {
+        Self::IpParseError(err.to_string())
+    }
+}
+
+impl ProxyError {
+    /// Creates an `InvalidXForwardedFor` error.
+    pub fn invalid_xff(msg: impl Into<String>) -> Self {
+        Self::InvalidXForwardedFor(msg.into())
+    }
+
+    /// Creates an `InvalidForwardedHeader` error.
+    pub fn invalid_forwarded(msg: impl Into<String>) -> Self {
+        Self::InvalidForwardedHeader(msg.into())
+    }
+
+    /// Creates a `ChainValidationFailed` error.
+    pub fn chain_failed(msg: impl Into<String>) -> Self {
+        Self::ChainValidationFailed(msg.into())
+    }
+
+    /// Creates an `UntrustedProxy` error.
+    pub fn untrusted(proxy: impl Into<String>) -> Self {
+        Self::UntrustedProxy(proxy.into())
+    }
+
+    /// Creates an `Internal` validation error.
+    pub fn internal(msg: impl Into<String>) -> Self {
+        Self::Internal(msg.into())
+    }
+
+    /// Determines if the error is recoverable, meaning the request can still be processed
+    /// (perhaps by falling back to the direct peer IP).
+    pub fn is_recoverable(&self) -> bool {
+        match self {
+            // These errors typically mean we should use the direct peer IP as a fallback.
+            Self::UntrustedProxy(_) => true,
+            Self::ChainTooLong(_, _) => true,
+            Self::ChainNotContinuous => true,
+
+            // These errors suggest malformed requests or severe configuration issues.
+            Self::InvalidXForwardedFor(_) => false,
+            Self::InvalidForwardedHeader(_) => false,
+            Self::ChainValidationFailed(_) => false,
+            Self::IpParseError(_) => false,
+            Self::HeaderParseError(_) => false,
+            Self::Timeout => true,
+            Self::Internal(_) => false,
+        }
+    }
+}