Struct HttpEndpointConfig 

pub struct HttpEndpointConfig {
    pub base_url: String,
    pub http_method: Option<String>,
    pub throw_exception_on_failure: bool,
    pub ok_status_code_range: (u16, u16),
    pub follow_redirects: bool,
    pub connect_timeout: Duration,
    pub response_timeout: Option<Duration>,
    pub query_params: HashMap<String, String>,
    pub allow_private_ips: bool,
    pub blocked_hosts: Vec<String>,
    pub max_body_size: usize,
}

Configuration for an HTTP client (producer) endpoint.

Memory Limits

HTTP operations enforce conservative memory limits to prevent denial-of-service attacks from untrusted network sources. These limits are significantly lower than file component limits (100MB) because HTTP typically handles API responses rather than large file transfers, and clients may be untrusted.

Default Limits

• HTTP client body: 10MB (typical API responses)
• HTTP server request: 2MB (untrusted network input - see HttpServerConfig)
• HTTP server response: 10MB (same as client - see HttpServerConfig)

Rationale

The 10MB limit for HTTP client responses is appropriate for most API interactions while providing protection against:

• Malicious servers sending oversized responses
• Runaway processes generating unexpectedly large payloads
• Memory exhaustion attacks

The 2MB server request limit is even more conservative because it handles input from potentially untrusted clients on the public internet.

Overriding Limits

Override the default client body limit using the maxBodySize URI parameter:

http://api.example.com/large-data?maxBodySize=52428800

For server endpoints, use maxRequestBody and maxResponseBody parameters:

http://0.0.0.0:8080/upload?maxRequestBody=52428800

Behavior When Exceeded

When a body exceeds the configured limit:

• An error is returned immediately
• No memory is exhausted - the limit is checked before allocation
• The HTTP connection is terminated cleanly

Security Considerations

HTTP endpoints should be treated with more caution than file endpoints because:

• Clients may be unknown and untrusted
• Network traffic can be spoofed or malicious
• DoS attacks often exploit unbounded resource consumption

Only increase limits when you control both ends of the connection or when business requirements demand larger payloads.

Fields

base_url: String

http_method: Option<String>

throw_exception_on_failure: bool

ok_status_code_range: (u16, u16)

follow_redirects: bool

connect_timeout: Duration

response_timeout: Option<Duration>

query_params: HashMap<String, String>

allow_private_ips: bool

blocked_hosts: Vec<String>

max_body_size: usize

Trait Implementations

impl Clone for HttpEndpointConfig

fn clone(&self) -> HttpEndpointConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HttpEndpointConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl UriConfig for HttpEndpointConfig

fn scheme() -> &'static str

Returns “http” as the primary scheme (also accepts “https”)

fn from_uri(uri: &str) -> Result<Self, CamelError>

Parse a URI string into this configuration.

fn from_components(parts: UriComponents) -> Result<Self, CamelError>

Parse already-extracted URI components into this configuration.

fn validate(self) -> Result<Self, CamelError>

Override to add validation logic after parsing.