warpdrive_proxy/router/

route.rs

//! Route matching and path transformation
//!
//! Routes are evaluated in order (first match wins).
//! Supports path prefix, exact path, regex, host-based, method-based, and header-based routing.

use anyhow::Result;
use pingora::prelude::*;
use regex::Regex;
use tracing::debug;

use crate::config::toml::{HeaderMatch, RouteConfig};

/// Route matching and upstream selection
#[derive(Debug)]
pub struct Route {
    /// Path prefix to match (e.g., "/api")
    path_prefix: Option<String>,

    /// Exact path to match
    path_exact: Option<String>,

    /// Regex pattern to match
    path_regex: Option<Regex>,

    /// Host header to match
    host: Option<String>,

    /// HTTP methods to match
    methods: Option<Vec<String>>,

    /// Header to match
    header: Option<HeaderMatch>,

    /// Target upstream name
    pub upstream_name: String,

    /// Strip the matched prefix before forwarding
    pub strip_prefix: bool,

    /// Rewrite the path
    pub rewrite: Option<String>,

    /// Description (for logging)
    #[allow(dead_code)]
    description: Option<String>,
}

impl Route {
    /// Create route from TOML configuration
    pub fn from_config(config: &RouteConfig) -> Result<Self> {
        let path_regex = if let Some(pattern) = &config.path_regex {
            Some(Regex::new(pattern)?)
        } else {
            None
        };

        Ok(Self {
            path_prefix: config.path_prefix.clone(),
            path_exact: config.path_exact.clone(),
            path_regex,
            host: config.host.clone(),
            methods: config.methods.clone(),
            header: config.header.clone(),
            upstream_name: config.upstream.clone(),
            strip_prefix: config.strip_prefix,
            rewrite: config.rewrite.clone(),
            description: config.description.clone(),
        })
    }

    /// Check if this route matches the incoming request
    pub fn matches(&self, session: &Session) -> bool {
        // 1. Check host match (if specified)
        if let Some(required_host) = &self.host {
            let request_host = session
                .req_header()
                .headers
                .get("host")
                .and_then(|h| h.to_str().ok());

            if request_host != Some(required_host.as_str()) {
                debug!(
                    "Route: host mismatch (required: {}, got: {:?})",
                    required_host, request_host
                );
                return false;
            }
        }

        // 2. Check method match (if specified)
        if let Some(allowed_methods) = &self.methods {
            let method = session.req_header().method.as_str();
            if !allowed_methods.iter().any(|m| m == method) {
                debug!(
                    "Route: method mismatch (allowed: {:?}, got: {})",
                    allowed_methods, method
                );
                return false;
            }
        }

        // 3. Check header match (if specified)
        if let Some(header_match) = &self.header {
            let header_value = session
                .req_header()
                .headers
                .get(&header_match.name)
                .and_then(|h| h.to_str().ok());

            if header_value != Some(header_match.value.as_str()) {
                debug!(
                    "Route: header mismatch ({}={}, got: {:?})",
                    header_match.name, header_match.value, header_value
                );
                return false;
            }
        }

        let path = session.req_header().uri.path();

        // 4. Check exact path match (highest priority)
        if let Some(exact_path) = &self.path_exact {
            if path == exact_path {
                debug!("Route: exact path match '{}'", exact_path);
                return true;
            } else {
                debug!(
                    "Route: exact path mismatch (required: {}, got: {})",
                    exact_path, path
                );
                return false;
            }
        }

        // 5. Check regex match
        if let Some(regex) = &self.path_regex {
            if regex.is_match(path) {
                debug!("Route: regex match '{}'", regex.as_str());
                return true;
            } else {
                debug!(
                    "Route: regex mismatch (pattern: {}, path: {})",
                    regex.as_str(),
                    path
                );
                return false;
            }
        }

        // 6. Check path prefix match
        if let Some(prefix) = &self.path_prefix {
            if path.starts_with(prefix) {
                debug!("Route: prefix match '{}'", prefix);
                return true;
            } else {
                debug!(
                    "Route: prefix mismatch (required: {}, got: {})",
                    prefix, path
                );
                return false;
            }
        }

        // 7. If no path matching specified, match all
        debug!("Route: match all (no path criteria)");
        true
    }

    /// Transform the path according to route configuration
    pub fn transform_path(&self, original: &str) -> String {
        // Priority: rewrite > strip_prefix > original
        if let Some(rewrite) = &self.rewrite {
            debug!("Route: rewriting path '{}' -> '{}'", original, rewrite);
            return rewrite.clone();
        }

        if self.strip_prefix {
            if let Some(prefix) = &self.path_prefix {
                let stripped = original.strip_prefix(prefix).unwrap_or(original);
                let result = if stripped.is_empty() { "/" } else { stripped };
                debug!(
                    "Route: stripping prefix '{}' from '{}' -> '{}'",
                    prefix, original, result
                );
                return result.to_string();
            }
        }

        original.to_string()
    }
}

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

    fn mock_session(method: &str, host: &str, path: &str) -> Session {
        // This is a simplified mock - in real tests we'd use Pingora's test utilities
        // For now, this shows the intended API
        unimplemented!("Mock session creation requires Pingora test utilities")
    }

    #[test]
    fn test_path_prefix_matching() {
        let config = RouteConfig {
            path_prefix: Some("/api".to_string()),
            path_exact: None,
            path_regex: None,
            host: None,
            methods: None,
            header: None,
            upstream: "api".to_string(),
            strip_prefix: false,
            rewrite: None,
            add_headers: vec![],
            read_timeout_secs: None,
            connect_timeout_secs: None,
            description: None,
        };

        let route = Route::from_config(&config).unwrap();
        assert_eq!(route.upstream_name, "api");
        assert_eq!(route.path_prefix, Some("/api".to_string()));
    }

    #[test]
    fn test_strip_prefix() {
        let route = Route {
            path_prefix: Some("/api".to_string()),
            path_exact: None,
            path_regex: None,
            host: None,
            methods: None,
            header: None,
            upstream_name: "api".to_string(),
            strip_prefix: true,
            rewrite: None,
            description: None,
        };

        assert_eq!(route.transform_path("/api/users"), "/users");
        assert_eq!(route.transform_path("/api"), "/");
        assert_eq!(route.transform_path("/other"), "/other");
    }

    #[test]
    fn test_rewrite_priority() {
        let route = Route {
            path_prefix: Some("/old".to_string()),
            path_exact: None,
            path_regex: None,
            host: None,
            methods: None,
            header: None,
            upstream_name: "api".to_string(),
            strip_prefix: true,
            rewrite: Some("/new".to_string()),
            description: None,
        };

        // Rewrite takes priority over strip_prefix
        assert_eq!(route.transform_path("/old/users"), "/new");
    }
}