api_bindium 0.4.0

Framework for api binding crates
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use core::time::Duration;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Instant;

#[cfg(any(feature = "sync", feature = "async"))]
use ureq::Body;
#[cfg(any(feature = "sync", feature = "async"))]
use ureq::RequestBuilder;
#[cfg(any(feature = "sync", feature = "async"))]
use ureq::http::Response;
use ureq::http::Uri;

use crate::HTTPVerb;

#[cfg(feature = "async")]
#[cfg_attr(docsrs, doc(cfg(feature = "async")))]
pub mod async_funcs;
#[cfg(feature = "sync")]
#[cfg_attr(docsrs, doc(cfg(feature = "sync")))]
pub mod sync_funcs;

/// A raw API request, used to send custom requests to the API
#[derive(Debug, Clone, bon::Builder)]
pub struct ApiRequest<P> {
    /// The uri to fetch
    #[builder(into)]
    uri: Uri,

    /// The http verb of the api request
    verb: HTTPVerb,

    /// The headers of the request
    #[builder(default)]
    headers: HashMap<String, String>,

    /// The body of the request
    body: Option<serde_json::Value>,

    /// The parser to use on the response
    #[builder(into)]
    #[cfg_attr(not(any(feature = "sync", feature = "async")), allow(dead_code))]
    parser: Arc<P>,

    /// The maximum size of the body of the response. This allows limiting response that may use more memories than it should
    #[builder(skip = 10 * 1024 * 1024)]
    max_body_size: u64,

    // === Fetching state ===
    /// The current number of times the request has been tried
    #[builder(skip)]
    pub tries: u32,

    /// Do not retry the query before this instant
    #[builder(skip = Instant::now())]
    pub retry_after: Instant,
}

impl<T> ApiRequest<T> {
    /// Return the uri to be fetched
    pub fn uri(&self) -> &Uri {
        &self.uri
    }

    /// Return the verb of the request
    pub fn verb(&self) -> HTTPVerb {
        self.verb
    }

    /// Return the headers of the request
    pub fn headers(&self) -> &HashMap<String, String> {
        &self.headers
    }

    /// Return the body of the request
    pub fn body(&self) -> &Option<serde_json::Value> {
        &self.body
    }

    pub fn max_body_size(&self) -> u64 {
        self.max_body_size
    }

    /// Reset the api request back to 0 tries
    pub fn reset(&mut self) {
        self.tries = 0
    }

    /// Increment the retry counter and set the new retry after
    pub fn increment_retry(&mut self, retry_after: Option<Instant>) {
        self.tries += 1;
        if let Some(retry_after) = retry_after {
            self.retry_after = retry_after;
            return;
        }

        let secs_to_wait = self.tries * (self.tries as f32 / 0.5).round() as u32;
        self.retry_after = Instant::now() + Duration::from_secs(secs_to_wait as u64)
    }

    /// Add the config to an ureq request
    #[cfg(any(feature = "sync", feature = "async"))]
    pub(super) fn config_req<Bod>(&self, req: RequestBuilder<Bod>) -> RequestBuilder<Bod> {
        let mut req = req.config().http_status_as_error(false).build();

        for (name, value) in &self.headers {
            req = req.header(name, value)
        }

        req
    }

    /// Set a new parser for the api request.
    pub fn set_parser<U>(self, parser: U) -> ApiRequest<U> {
        ApiRequest {
            body: self.body,
            headers: self.headers,
            max_body_size: self.max_body_size,
            parser: Arc::new(parser),
            retry_after: self.retry_after,
            tries: self.tries,
            uri: self.uri,
            verb: self.verb,
        }
    }

    pub fn headers_mut(&mut self) -> &mut HashMap<String, String> {
        &mut self.headers
    }
}

#[cfg(any(feature = "sync", feature = "async"))]
fn get_temporary_error_timeout(response: &Response<Body>) -> Option<Instant> {
    let headers = response.headers();

    let retry_after = headers.get("retry-after")?;

    let Ok(retry_after) = retry_after.to_str() else {
        return None;
    };

    let Ok(retry_after) = retry_after.parse::<u64>() else {
        return None;
    };

    Some(Instant::now() + Duration::from_secs(retry_after + 1))
}