uclient 0.2.3

Universal HTTP client for Rust
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

#![allow(unused_imports)]
#![allow(unused_parens)]
#[cfg(feature = "async_reqwest")]
use futures::StreamExt;
use http::{HeaderMap, HeaderValue, Method};
#[cfg(feature = "async_reqwest")]
use reqwest::{Body, Client};
use url::Url;

use http::request::Parts;
use std::convert::TryInto;
use std::io::Read;
use uclient::{ClientExt, Error};

/// when use async http client, `blocking` feature MUST be disabled
// This cfg is only to make rust compiler happy in Github Action, you can just ignore it
#[cfg(feature = "async_reqwest")]
#[derive(Debug, Clone)]
pub struct ReqwestClient(pub Client, HeaderMap);

/// This cfg is only to make rust compiler happy in Github Action, you can just
/// ignore it
#[cfg(feature = "async_reqwest")]
#[async_trait::async_trait]
impl ClientExt for ReqwestClient {
    fn new<U: Into<Option<HeaderMap>>>(headers: U) -> Result<Self, Error> {
        let headers = match headers.into() {
            Some(h) => h,
            None => HeaderMap::new(),
        };

        Client::builder()
            .build()
            .map(|c| ReqwestClient(c, headers))
            .map_err(|e| Error::HttpClient(format!("{:?}", e)))
    }

    fn headers(&mut self) -> &mut HeaderMap<HeaderValue> {
        &mut self.1
    }

    async fn request_reader<T>(
        &self,
        mut request: http::Request<T>,
    ) -> Result<http::Response<String>, Error>
    where
        T: Read + Send + Sync + 'static,
    {
        // construct reqwest body
        let (parts, body) = request.into_parts();
        let Parts {
            method,
            uri,
            headers,
            ..
        } = parts;
        let url = Url::parse(&uri.to_string()).expect("invalid url");
        let mut request = reqwest::Request::new(method, url);

        // insert header
        let mut prev_name = None;
        for (key, value) in headers {
            match key {
                Some(key) => {
                    request.headers_mut().insert(key.clone(), value);
                    prev_name = Some(key);
                }
                None => match prev_name {
                    Some(ref key) => {
                        request.headers_mut().append(key.clone(), value);
                    }
                    None => unreachable!("HeaderMap::into_iter yielded None first"),
                },
            }
        }

        // convert an object with read trait to stream
        let body_bytes = body.bytes();
        let stream = futures::stream::iter(body_bytes).chunks(2048).map(|x| {
            let len = x.len();
            let out = x.into_iter().filter_map(|b| b.ok()).collect::<Vec<_>>();
            if out.len() == len {
                Ok(out)
            } else {
                Err(crate::Error::PayloadError)
            }
        });
        request.body_mut().replace(Body::wrap_stream(stream));

        let resp = self
            .0
            .execute(request)
            .await
            .map_err(|e| Error::HttpClient(format!("{:?}", e)))?;
        let status_code = resp.status();
        let headers = resp.headers().clone();
        let version = resp.version();
        let content = resp
            .text()
            .await
            .map_err(|e| Error::HttpClient(format!("{:?}", e)))?;
        let mut build = http::Response::builder();

        for header in headers.iter() {
            build = build.header(header.0, header.1);
        }

        http::response::Builder::from(build)
            .status(status_code)
            .version(version)
            .body(content)
            .map_err(|e| Error::HttpClient(format!("{:?}", e)))
    }
}

// This cfg is only to make rust compiler happy in Github Action, you can just
// ignore it
#[cfg(feature = "async_reqwest")]
#[tokio::main]
async fn main() {
    let client = ReqwestClient::new(None).unwrap();
    let res = client
        .get(url::Url::parse("https://www.rust-lang.org/").unwrap(), "")
        .await
        .unwrap();
    println!("{}", res.body());
}

#[cfg(not(feature = "async_reqwest"))]
fn main() {}