simple-hyper-client 0.2.0

A wrapper for hyper's HTTP client providing a simpler interface as well as a blocking interface
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

/* Copyright (c) Fortanix, Inc.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use crate::{
    connector::http::{DEFAULT_HTTPS_PORT, DEFAULT_HTTP_PORT},
    ConnectError, HttpConnection,
};
use hyper::Uri;
use std::io;
use std::net::Ipv6Addr;
use std::str::FromStr;
use std::time::Duration;
use tokio::net::TcpStream;
use tokio::time;

pub async fn connect(
    uri: Uri,
    allow_https: bool,
    connect_timeout: Option<Duration>,
) -> Result<HttpConnection, ConnectError> {
    match uri.scheme_str() {
        Some("http") => {}
        Some("https") if allow_https => {}
        Some(_) => {
            return Err(ConnectError::new(if allow_https {
                "invalid URI: expected `http` or `https` scheme"
            } else {
                "invalid URI: expected `http` scheme"
            }))
        }
        None => return Err(ConnectError::new("invalid URI: missing scheme")),
    }
    let host = get_host(&uri)?;
    let port = uri.port_u16().unwrap_or_else(|| {
        if uri.scheme_str() == Some("http") {
            DEFAULT_HTTP_PORT
        } else {
            DEFAULT_HTTPS_PORT
        }
    });
    let connect = TcpStream::connect((host, port));
    let stream = match connect_timeout {
        Some(duration) => match time::timeout(duration, connect).await {
            Ok(Ok(stream)) => Ok(stream),
            Ok(Err(e)) => Err(e),
            Err(_) => Err(io::Error::new(
                io::ErrorKind::TimedOut,
                "connection timed out",
            )),
        },
        None => connect.await,
    }
    .map_err(|e| ConnectError::new("I/O error").cause(e))?;

    Ok(HttpConnection { stream })
}

pub fn get_host(uri: &Uri) -> Result<&str, ConnectError> {
    let host = uri
        .host()
        .ok_or(ConnectError::new("invalid URI: missing host"))?;

    if host.starts_with("[") && host.ends_with("]") {
        let maybe_ipv6 = host.strip_prefix('[').unwrap().strip_suffix(']').unwrap();
        if let Ok(_) = Ipv6Addr::from_str(maybe_ipv6) {
            return Ok(maybe_ipv6);
        }
    }
    Ok(host)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn get_host_correctness() {
        assert_eq!(
            get_host(&Uri::from_static("http://example.com")).ok(),
            Some("example.com")
        );
        assert_eq!(
            get_host(&Uri::from_static("http://1.2.3.4:80/test")).ok(),
            Some("1.2.3.4")
        );
        assert_eq!(
            get_host(&Uri::from_static("http://[::1]")).ok(),
            Some("::1")
        );
        assert_eq!(
            get_host(&Uri::from_static("http://[::1.2.3.4]:8080")).ok(),
            Some("::1.2.3.4")
        );
        assert_eq!(
            get_host(&Uri::from_static("http://[test.com]")).ok(),
            Some("[test.com]")
        );
    }
}