ezhttp 0.2.2

Simple async http library with client and server
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
148
149
150
151
152
153
154
155
156
157
158
159

use std::time::Duration;

use crate::{error::HttpError, headers::Headers, prelude::HttpResponse, request::HttpRequest};

use super::{send_request, Proxy};

/// Client that sends http requests
pub struct HttpClient {
    proxy: Proxy,
    ssl_verify: bool,
    headers: Headers,
    connect_timeout: Option<Duration>, 
    write_timeout: Option<Duration>, 
    read_timeout: Option<Duration>
}

/// [`HttpClient`](HttpClient) builder
pub struct ClientBuilder {
    proxy: Proxy,
    ssl_verify: bool,
    headers: Headers,
    connect_timeout: Option<Duration>, 
    write_timeout: Option<Duration>, 
    read_timeout: Option<Duration>
}

impl ClientBuilder {
    /// Create a client builder
    pub fn new() -> ClientBuilder {
        ClientBuilder {
            proxy: Proxy::None,
            ssl_verify: true,
            headers: Headers::new(),
            connect_timeout: None, 
            write_timeout: None, 
            read_timeout: None
        }
    }

    /// Build a client
    pub fn build(self) -> HttpClient {
        HttpClient { 
            proxy: self.proxy, 
            ssl_verify: self.ssl_verify, 
            headers: self.headers,
            connect_timeout: self.connect_timeout,
            write_timeout: self.write_timeout,
            read_timeout: self.read_timeout
        }
    }

    /// Set request timeouts0
    pub fn timeout(mut self, connect: Option<Duration>, read: Option<Duration>, write: Option<Duration>) -> Self {
        self.connect_timeout = connect;
        self.read_timeout = read;
        self.write_timeout = write;
        self
    }

    /// Set connect timeout
    pub fn connect_timeout(mut self, timeout: Duration) -> Self {
        self.connect_timeout = Some(timeout);
        self
    }

    /// Set read timeout
    pub fn read_timeout(mut self, timeout: Duration) -> Self {
        self.read_timeout = Some(timeout);
        self
    }

    /// Set write timeout
    pub fn write_timeout(mut self, timeout: Duration) -> Self {
        self.write_timeout = Some(timeout);
        self
    }

    /// Set client proxy
    pub fn proxy(mut self, proxy: Proxy) -> Self {
        self.proxy = proxy;
        self
    }

    /// Set is client have to verify ssl certificate
    pub fn ssl_verify(mut self, verify: bool) -> Self {
        self.ssl_verify = verify;
        self
    }

    /// Set default headers
    pub fn headers(mut self, headers: Headers) -> Self {
        self.headers = headers;
        self
    }

    /// Set default header
    pub fn header(mut self, name: impl ToString, value: impl ToString) -> Self {
        self.headers.put(name, value.to_string());
        self
    }
}

impl HttpClient {
    /// Get new HttpClient builder
    pub fn builder() -> ClientBuilder {
        ClientBuilder::new()
    }

    /// Sends a request and receives a response
    pub async fn send(&self, request: HttpRequest) -> Result<HttpResponse, HttpError> {
        send_request(
            request, 
            self.ssl_verify, 
            self.proxy.clone(), 
            self.headers.clone(),
            self.connect_timeout,
            self.write_timeout,
            self.read_timeout
        ).await
    }

    /// Get connect timeout
    pub fn connect_timeout(&self) -> Option<Duration> {
        self.connect_timeout.clone()
    }

    /// Get read timeout
    pub fn read_timeout(&self) -> Option<Duration> {
        self.read_timeout.clone()
    }

    /// Get write timeout
    pub fn write_timeout(&self) -> Option<Duration> {
        self.write_timeout.clone()
    }

    /// Get client proxy
    pub fn proxy(&self) -> Proxy {
        self.proxy.clone()
    }

    /// Get is client have to verify ssl certificate
    pub fn ssl_verify(&self) -> bool {
        self.ssl_verify
    }

    /// Get default headers
    pub fn headers(&self) -> Headers {
        self.headers.clone()
    }
}

impl Default for HttpClient {
    /// Create default HttpClient
    fn default() -> Self {
        ClientBuilder::new().build()
    }
}