Struct CreateProxyConfig 

pub struct CreateProxyConfig {
    pub proxy_url: String,
    pub include_paths: Vec<String>,
    pub exclude_paths: Vec<String>,
    pub enable_websocket: bool,
    pub forward_get_only: bool,
    pub cache_key_fn: Arc<dyn Fn(&RequestInfo<'_>) -> String + Send + Sync>,
    pub cache_404_capacity: usize,
    pub use_404_meta: bool,
    pub cache_strategy: CacheStrategy,
    pub compress_strategy: CompressStrategy,
    pub cache_storage_mode: CacheStorageMode,
    pub cache_directory: Option<PathBuf>,
}

Configuration for creating a proxy

Fields

proxy_url: String

The backend URL to proxy requests to

include_paths: Vec<String>

Paths to include in caching (empty means include all) Supports wildcards and method prefixes: “/api/”, “POST /api/”, “GET /*/users”, etc.

exclude_paths: Vec<String>

Paths to exclude from caching (empty means exclude none) Supports wildcards and method prefixes: “/admin/*”, “POST ”, “PUT /api/”, etc. Exclude overrides include

enable_websocket: bool

Enable WebSocket and protocol upgrade support (default: true) When enabled, requests with Connection: Upgrade headers will bypass the cache and establish a direct bidirectional TCP tunnel

forward_get_only: bool

Only allow GET requests, reject all others (default: false) When true, only GET requests are processed; POST, PUT, DELETE, etc. return 405 Method Not Allowed Useful for static site prerendering where mutations shouldn’t be allowed

cache_key_fn: Arc<dyn Fn(&RequestInfo<'_>) -> String + Send + Sync>

Custom cache key generator Takes request info and returns a cache key Default: method + path + query string

cache_404_capacity: usize

Capacity for special 404 cache. When 0, 404 caching is disabled.

use_404_meta: bool

When true, treat a response containing the meta tag <meta name="phantom-404" content="true"> as a 404 This is an optional performance-affecting fallback to detect framework-generated 404 pages.

cache_strategy: CacheStrategy

Controls which responses should be cached after the backend responds.

compress_strategy: CompressStrategy

Controls how cached bodies are stored in memory.

cache_storage_mode: CacheStorageMode

Controls where cached response bodies are stored.

cache_directory: Option<PathBuf>

Optional override for filesystem-backed cache bodies.

Implementations

impl CreateProxyConfig

pub fn new(proxy_url: String) -> Self

Create a new config with default settings

Examples found in repository

examples/library_usage.rs (line 13)

async fn main() {
    // Initialize tracing (optional but recommended)
    // tracing_subscriber::fmt::init();

    // Create proxy configuration
    // You can specify method prefixes to filter by HTTP method
    let proxy_config = CreateProxyConfig::new("http://localhost:8080".to_string())
        .with_include_paths(vec![
            "/api/*".to_string(),
            "/public/*".to_string(),
            "GET /admin/stats".to_string(), // Only cache GET requests to this endpoint
        ])
        .with_exclude_paths(vec![
            "/api/admin/*".to_string(),
            "POST *".to_string(),   // Don't cache any POST requests
            "PUT *".to_string(),    // Don't cache any PUT requests
            "DELETE *".to_string(), // Don't cache any DELETE requests
        ])
        .caching_strategy(CacheStrategy::None)
        .compression_strategy(CompressStrategy::Brotli)
        .with_websocket_enabled(true); // Enable WebSocket support (default: true)

    // Create proxy - proxy_url is the backend server to proxy requests to
    let (proxy_app, refresh_trigger): (Router, RefreshTrigger) = create_proxy(proxy_config);

    // You can clone and use the refresh_trigger in your code
    let trigger_clone = refresh_trigger.clone();

    // Example: Trigger cache refresh from another part of your application
    tokio::spawn(async move {
        tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;

        // Clear all cache entries
        trigger_clone.trigger();
        println!("All cache cleared!");

        tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;

        // Clear only cache entries matching a pattern (supports wildcards)
        trigger_clone.trigger_by_key_match("GET:/api/*");
        println!("Cache cleared for GET:/api/* pattern!");
    });

    // Start the proxy server
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

    println!("Proxy server listening on http://0.0.0.0:3000");
    println!("Caching paths: /api/*, /public/*, GET /admin/stats");
    println!("Excluding: /api/admin/*, POST *, PUT *, DELETE *");
    println!("Cache strategy: none (proxy-only mode)");
    println!("Compression strategy: brotli (applies only to cached responses)");
    println!("Note: Cache reads and writes are disabled in this example");
    println!("WebSocket support: enabled");

    axum::serve(listener, proxy_app).await.unwrap();
}

pub fn with_include_paths(self, paths: Vec<String>) -> Self

Set include paths

Examples found in repository

examples/library_usage.rs (lines 14-18)

async fn main() {
    // Initialize tracing (optional but recommended)
    // tracing_subscriber::fmt::init();

    // Create proxy configuration
    // You can specify method prefixes to filter by HTTP method
    let proxy_config = CreateProxyConfig::new("http://localhost:8080".to_string())
        .with_include_paths(vec![
            "/api/*".to_string(),
            "/public/*".to_string(),
            "GET /admin/stats".to_string(), // Only cache GET requests to this endpoint
        ])
        .with_exclude_paths(vec![
            "/api/admin/*".to_string(),
            "POST *".to_string(),   // Don't cache any POST requests
            "PUT *".to_string(),    // Don't cache any PUT requests
            "DELETE *".to_string(), // Don't cache any DELETE requests
        ])
        .caching_strategy(CacheStrategy::None)
        .compression_strategy(CompressStrategy::Brotli)
        .with_websocket_enabled(true); // Enable WebSocket support (default: true)

    // Create proxy - proxy_url is the backend server to proxy requests to
    let (proxy_app, refresh_trigger): (Router, RefreshTrigger) = create_proxy(proxy_config);

    // You can clone and use the refresh_trigger in your code
    let trigger_clone = refresh_trigger.clone();

    // Example: Trigger cache refresh from another part of your application
    tokio::spawn(async move {
        tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;

        // Clear all cache entries
        trigger_clone.trigger();
        println!("All cache cleared!");

        tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;

        // Clear only cache entries matching a pattern (supports wildcards)
        trigger_clone.trigger_by_key_match("GET:/api/*");
        println!("Cache cleared for GET:/api/* pattern!");
    });

    // Start the proxy server
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

    println!("Proxy server listening on http://0.0.0.0:3000");
    println!("Caching paths: /api/*, /public/*, GET /admin/stats");
    println!("Excluding: /api/admin/*, POST *, PUT *, DELETE *");
    println!("Cache strategy: none (proxy-only mode)");
    println!("Compression strategy: brotli (applies only to cached responses)");
    println!("Note: Cache reads and writes are disabled in this example");
    println!("WebSocket support: enabled");

    axum::serve(listener, proxy_app).await.unwrap();
}

pub fn with_exclude_paths(self, paths: Vec<String>) -> Self

Set exclude paths

Examples found in repository

examples/library_usage.rs (lines 19-24)

async fn main() {
    // Initialize tracing (optional but recommended)
    // tracing_subscriber::fmt::init();

    // Create proxy configuration
    // You can specify method prefixes to filter by HTTP method
    let proxy_config = CreateProxyConfig::new("http://localhost:8080".to_string())
        .with_include_paths(vec![
            "/api/*".to_string(),
            "/public/*".to_string(),
            "GET /admin/stats".to_string(), // Only cache GET requests to this endpoint
        ])
        .with_exclude_paths(vec![
            "/api/admin/*".to_string(),
            "POST *".to_string(),   // Don't cache any POST requests
            "PUT *".to_string(),    // Don't cache any PUT requests
            "DELETE *".to_string(), // Don't cache any DELETE requests
        ])
        .caching_strategy(CacheStrategy::None)
        .compression_strategy(CompressStrategy::Brotli)
        .with_websocket_enabled(true); // Enable WebSocket support (default: true)

    // Create proxy - proxy_url is the backend server to proxy requests to
    let (proxy_app, refresh_trigger): (Router, RefreshTrigger) = create_proxy(proxy_config);

    // You can clone and use the refresh_trigger in your code
    let trigger_clone = refresh_trigger.clone();

    // Example: Trigger cache refresh from another part of your application
    tokio::spawn(async move {
        tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;

        // Clear all cache entries
        trigger_clone.trigger();
        println!("All cache cleared!");

        tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;

        // Clear only cache entries matching a pattern (supports wildcards)
        trigger_clone.trigger_by_key_match("GET:/api/*");
        println!("Cache cleared for GET:/api/* pattern!");
    });

    // Start the proxy server
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

    println!("Proxy server listening on http://0.0.0.0:3000");
    println!("Caching paths: /api/*, /public/*, GET /admin/stats");
    println!("Excluding: /api/admin/*, POST *, PUT *, DELETE *");
    println!("Cache strategy: none (proxy-only mode)");
    println!("Compression strategy: brotli (applies only to cached responses)");
    println!("Note: Cache reads and writes are disabled in this example");
    println!("WebSocket support: enabled");

    axum::serve(listener, proxy_app).await.unwrap();
}

pub fn with_websocket_enabled(self, enabled: bool) -> Self

Enable or disable WebSocket and protocol upgrade support

Examples found in repository

examples/library_usage.rs (line 27)

async fn main() {
    // Initialize tracing (optional but recommended)
    // tracing_subscriber::fmt::init();

    // Create proxy configuration
    // You can specify method prefixes to filter by HTTP method
    let proxy_config = CreateProxyConfig::new("http://localhost:8080".to_string())
        .with_include_paths(vec![
            "/api/*".to_string(),
            "/public/*".to_string(),
            "GET /admin/stats".to_string(), // Only cache GET requests to this endpoint
        ])
        .with_exclude_paths(vec![
            "/api/admin/*".to_string(),
            "POST *".to_string(),   // Don't cache any POST requests
            "PUT *".to_string(),    // Don't cache any PUT requests
            "DELETE *".to_string(), // Don't cache any DELETE requests
        ])
        .caching_strategy(CacheStrategy::None)
        .compression_strategy(CompressStrategy::Brotli)
        .with_websocket_enabled(true); // Enable WebSocket support (default: true)

    // Create proxy - proxy_url is the backend server to proxy requests to
    let (proxy_app, refresh_trigger): (Router, RefreshTrigger) = create_proxy(proxy_config);

    // You can clone and use the refresh_trigger in your code
    let trigger_clone = refresh_trigger.clone();

    // Example: Trigger cache refresh from another part of your application
    tokio::spawn(async move {
        tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;

        // Clear all cache entries
        trigger_clone.trigger();
        println!("All cache cleared!");

        tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;

        // Clear only cache entries matching a pattern (supports wildcards)
        trigger_clone.trigger_by_key_match("GET:/api/*");
        println!("Cache cleared for GET:/api/* pattern!");
    });

    // Start the proxy server
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

    println!("Proxy server listening on http://0.0.0.0:3000");
    println!("Caching paths: /api/*, /public/*, GET /admin/stats");
    println!("Excluding: /api/admin/*, POST *, PUT *, DELETE *");
    println!("Cache strategy: none (proxy-only mode)");
    println!("Compression strategy: brotli (applies only to cached responses)");
    println!("Note: Cache reads and writes are disabled in this example");
    println!("WebSocket support: enabled");

    axum::serve(listener, proxy_app).await.unwrap();
}

pub fn with_forward_get_only(self, enabled: bool) -> Self

Only allow GET requests, reject all others

pub fn with_cache_key_fn<F>(self, f: F) -> Self

where F: Fn(&RequestInfo<'_>) -> String + Send + Sync + 'static,

Set custom cache key function

pub fn with_cache_404_capacity(self, capacity: usize) -> Self

Set 404 cache capacity. When 0, 404 caching is disabled.

pub fn with_use_404_meta(self, enabled: bool) -> Self

Treat pages that include the special meta tag as 404 pages

pub fn with_cache_strategy(self, strategy: CacheStrategy) -> Self

Set the cache strategy used to decide which response types are stored.

pub fn caching_strategy(self, strategy: CacheStrategy) -> Self

Alias for callers that prefer a more fluent builder name.

Examples found in repository

examples/library_usage.rs (line 25)

async fn main() {
    // Initialize tracing (optional but recommended)
    // tracing_subscriber::fmt::init();

    // Create proxy configuration
    // You can specify method prefixes to filter by HTTP method
    let proxy_config = CreateProxyConfig::new("http://localhost:8080".to_string())
        .with_include_paths(vec![
            "/api/*".to_string(),
            "/public/*".to_string(),
            "GET /admin/stats".to_string(), // Only cache GET requests to this endpoint
        ])
        .with_exclude_paths(vec![
            "/api/admin/*".to_string(),
            "POST *".to_string(),   // Don't cache any POST requests
            "PUT *".to_string(),    // Don't cache any PUT requests
            "DELETE *".to_string(), // Don't cache any DELETE requests
        ])
        .caching_strategy(CacheStrategy::None)
        .compression_strategy(CompressStrategy::Brotli)
        .with_websocket_enabled(true); // Enable WebSocket support (default: true)

    // Create proxy - proxy_url is the backend server to proxy requests to
    let (proxy_app, refresh_trigger): (Router, RefreshTrigger) = create_proxy(proxy_config);

    // You can clone and use the refresh_trigger in your code
    let trigger_clone = refresh_trigger.clone();

    // Example: Trigger cache refresh from another part of your application
    tokio::spawn(async move {
        tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;

        // Clear all cache entries
        trigger_clone.trigger();
        println!("All cache cleared!");

        tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;

        // Clear only cache entries matching a pattern (supports wildcards)
        trigger_clone.trigger_by_key_match("GET:/api/*");
        println!("Cache cleared for GET:/api/* pattern!");
    });

    // Start the proxy server
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

    println!("Proxy server listening on http://0.0.0.0:3000");
    println!("Caching paths: /api/*, /public/*, GET /admin/stats");
    println!("Excluding: /api/admin/*, POST *, PUT *, DELETE *");
    println!("Cache strategy: none (proxy-only mode)");
    println!("Compression strategy: brotli (applies only to cached responses)");
    println!("Note: Cache reads and writes are disabled in this example");
    println!("WebSocket support: enabled");

    axum::serve(listener, proxy_app).await.unwrap();
}

pub fn with_compress_strategy(self, strategy: CompressStrategy) -> Self

Set the compression strategy used for stored cache entries.

pub fn compression_strategy(self, strategy: CompressStrategy) -> Self

Alias for callers that prefer a more fluent builder name.

Examples found in repository

examples/library_usage.rs (line 26)

async fn main() {
    // Initialize tracing (optional but recommended)
    // tracing_subscriber::fmt::init();

    // Create proxy configuration
    // You can specify method prefixes to filter by HTTP method
    let proxy_config = CreateProxyConfig::new("http://localhost:8080".to_string())
        .with_include_paths(vec![
            "/api/*".to_string(),
            "/public/*".to_string(),
            "GET /admin/stats".to_string(), // Only cache GET requests to this endpoint
        ])
        .with_exclude_paths(vec![
            "/api/admin/*".to_string(),
            "POST *".to_string(),   // Don't cache any POST requests
            "PUT *".to_string(),    // Don't cache any PUT requests
            "DELETE *".to_string(), // Don't cache any DELETE requests
        ])
        .caching_strategy(CacheStrategy::None)
        .compression_strategy(CompressStrategy::Brotli)
        .with_websocket_enabled(true); // Enable WebSocket support (default: true)

    // Create proxy - proxy_url is the backend server to proxy requests to
    let (proxy_app, refresh_trigger): (Router, RefreshTrigger) = create_proxy(proxy_config);

    // You can clone and use the refresh_trigger in your code
    let trigger_clone = refresh_trigger.clone();

    // Example: Trigger cache refresh from another part of your application
    tokio::spawn(async move {
        tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;

        // Clear all cache entries
        trigger_clone.trigger();
        println!("All cache cleared!");

        tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;

        // Clear only cache entries matching a pattern (supports wildcards)
        trigger_clone.trigger_by_key_match("GET:/api/*");
        println!("Cache cleared for GET:/api/* pattern!");
    });

    // Start the proxy server
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

    println!("Proxy server listening on http://0.0.0.0:3000");
    println!("Caching paths: /api/*, /public/*, GET /admin/stats");
    println!("Excluding: /api/admin/*, POST *, PUT *, DELETE *");
    println!("Cache strategy: none (proxy-only mode)");
    println!("Compression strategy: brotli (applies only to cached responses)");
    println!("Note: Cache reads and writes are disabled in this example");
    println!("WebSocket support: enabled");

    axum::serve(listener, proxy_app).await.unwrap();
}

pub fn with_cache_storage_mode(self, mode: CacheStorageMode) -> Self

Set the backing store for cached response bodies.

pub fn with_cache_directory(self, directory: impl Into<PathBuf>) -> Self

Set the filesystem directory used for disk-backed cache bodies.

Trait Implementations

impl Clone for CreateProxyConfig

fn clone(&self) -> CreateProxyConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.