wvb 0.2.0-next.e0bfd59

Offline-first web resources delivery system for webview mounted frameworks/platforms
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

use reqwest::header::HeaderMap;

#[derive(Debug, Clone, Default)]
pub struct HttpConfig {
  pub default_headers: Option<HeaderMap>,
  pub user_agent: Option<String>,
  pub timeout: Option<u64>,
  pub read_timeout: Option<u64>,
  pub connect_timeout: Option<u64>,
  pub pool_idle_timeout: Option<u64>,
  pub pool_max_idle_per_host: Option<usize>,
  pub referer: Option<bool>,
  pub tcp_nodelay: Option<bool>,
  pub hickory_dns: Option<bool>,
}

impl HttpConfig {
  pub fn new() -> Self {
    Self::default()
  }

  pub fn default_headers(mut self, headers: HeaderMap) -> Self {
    self.default_headers = Some(headers);
    self
  }

  pub fn user_agent(mut self, user_agent: impl Into<String>) -> Self {
    self.user_agent = Some(user_agent.into());
    self
  }

  pub fn timeout(mut self, timeout: u64) -> Self {
    self.timeout = Some(timeout);
    self
  }

  pub fn read_timeout(mut self, read_timeout: u64) -> Self {
    self.read_timeout = Some(read_timeout);
    self
  }

  pub fn connect_timeout(mut self, connect_timeout: u64) -> Self {
    self.connect_timeout = Some(connect_timeout);
    self
  }

  pub fn pool_idle_timeout(mut self, pool_idle_timeout: u64) -> Self {
    self.pool_idle_timeout = Some(pool_idle_timeout);
    self
  }

  pub fn pool_max_idle_per_host(mut self, pool_max_idle_per_host: usize) -> Self {
    self.pool_max_idle_per_host = Some(pool_max_idle_per_host);
    self
  }

  pub fn referer(mut self, referer: bool) -> Self {
    self.referer = Some(referer);
    self
  }

  pub fn tcp_nodelay(mut self, tcp_nodelay: bool) -> Self {
    self.tcp_nodelay = Some(tcp_nodelay);
    self
  }

  pub fn hickory_dns(mut self, hickory_dns: bool) -> Self {
    self.hickory_dns = Some(hickory_dns);
    self
  }

  pub(crate) fn apply(&self, mut http: reqwest::ClientBuilder) -> reqwest::ClientBuilder {
    if let Some(default_headers) = self.default_headers.as_ref() {
      http = http.default_headers(default_headers.clone());
    }
    if let Some(user_agent) = self.user_agent.as_ref() {
      http = http.user_agent(user_agent);
    }
    if let Some(timeout) = self.timeout {
      http = http.timeout(std::time::Duration::from_millis(timeout));
    }
    if let Some(pool_idle_timeout) = self.pool_idle_timeout {
      http = http.pool_idle_timeout(std::time::Duration::from_millis(pool_idle_timeout));
    }
    if let Some(pool_max_idle_per_host) = self.pool_max_idle_per_host {
      http = http.pool_max_idle_per_host(pool_max_idle_per_host);
    }
    if let Some(referer) = self.referer {
      http = http.referer(referer);
    }
    if let Some(tcp_nodelay) = self.tcp_nodelay {
      http = http.tcp_nodelay(tcp_nodelay);
    }
    http
  }
}