gazelle_api 0.6.0-alpha.1

Gazelle API Client
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

use std::time::Duration;

use reqwest::header::{HeaderMap, HeaderValue};
use reqwest::{header, Client, ClientBuilder};

use crate::{GazelleClient, GazelleClientOptions, RateLimiter};

const DEFAULT_LIMIT: usize = 2;
const DEFAULT_LIMIT_DURATION: Duration = Duration::from_secs(1);

/// Create a [`GazelleClient`]
pub struct GazelleClientFactory {
    pub options: GazelleClientOptions,
}

impl GazelleClientFactory {
    #[must_use]
    pub fn create(self) -> GazelleClient {
        let GazelleClientOptions {
            user_agent,
            key,
            url: base_url,
            requests_allowed_per_duration: num,
            request_limit_duration: per,
        } = self.options;
        let client = create_client(user_agent, key);
        let limiter = RateLimiter::new(
            num.unwrap_or(DEFAULT_LIMIT),
            per.unwrap_or(DEFAULT_LIMIT_DURATION),
        );
        GazelleClient {
            base_url,
            client,
            limiter,
        }
    }
}

fn create_client(user_agent: String, key: String) -> Client {
    ClientBuilder::new()
        .default_headers(get_headers(user_agent, key))
        .build()
        .expect("Client builder should not fail")
}

fn get_headers(user_agent: String, key: String) -> HeaderMap {
    let mut headers = HeaderMap::new();
    headers.insert(
        header::USER_AGENT,
        HeaderValue::try_from(user_agent).expect("user agent should not fail"),
    );
    headers.insert(header::ACCEPT, HeaderValue::from_static("application/json"));
    headers.insert(header::AUTHORIZATION, get_authorization(key));
    headers
}

fn get_authorization(key: String) -> HeaderValue {
    let mut value = HeaderValue::try_from(key).expect("Authorization header should not fail");
    value.set_sensitive(true);
    value
}