reqx 0.1.35

Rust HTTP transport client for API SDK libraries with retry, timeout, idempotency, proxy, and pluggable TLS backends
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

use std::time::Duration;

use http::{HeaderMap, Method};

use crate::policy::{RedirectPolicy, StatusPolicy};
use crate::retry::RetryPolicy;
use crate::util::append_query_pairs;

#[derive(Default)]
pub(crate) struct RequestExecutionOverrides {
    pub(crate) request_timeout: Option<Duration>,
    pub(crate) total_timeout: Option<Duration>,
    pub(crate) max_response_body_bytes: Option<usize>,
    pub(crate) retry_policy: Option<RetryPolicy>,
    pub(crate) redirect_policy: Option<RedirectPolicy>,
    pub(crate) status_policy: Option<StatusPolicy>,
    pub(crate) auto_accept_encoding: Option<bool>,
}

impl RequestExecutionOverrides {
    fn with_forced_status_policy(mut self, forced_status_policy: Option<StatusPolicy>) -> Self {
        self.status_policy = forced_status_policy.or(self.status_policy);
        self
    }
}

pub(crate) struct PreparedRequest<'a, ClientRef, Body, ExecutionOptions> {
    pub(crate) client: &'a ClientRef,
    pub(crate) method: Method,
    pub(crate) path: String,
    pub(crate) headers: HeaderMap,
    pub(crate) body: Option<Body>,
    pub(crate) execution_options: ExecutionOptions,
}

pub(crate) struct RequestPreparation<'a, ClientRef, Body> {
    pub(crate) client: &'a ClientRef,
    pub(crate) method: Method,
    pub(crate) path: String,
    pub(crate) query_pairs: Vec<(String, String)>,
    pub(crate) headers: HeaderMap,
    pub(crate) body: Option<Body>,
    pub(crate) execution_overrides: RequestExecutionOverrides,
}

impl<'a, ClientRef, Body> RequestPreparation<'a, ClientRef, Body> {
    pub(crate) fn prepare<ExecutionOptions, F>(
        self,
        forced_status_policy: Option<StatusPolicy>,
        build_execution_options: F,
    ) -> PreparedRequest<'a, ClientRef, Body, ExecutionOptions>
    where
        F: FnOnce(RequestExecutionOverrides) -> ExecutionOptions,
    {
        PreparedRequest {
            client: self.client,
            method: self.method,
            path: append_query_pairs(&self.path, &self.query_pairs),
            headers: self.headers,
            body: self.body,
            execution_options: build_execution_options(
                self.execution_overrides
                    .with_forced_status_policy(forced_status_policy),
            ),
        }
    }
}