leyline-http 0.1.1

HTTP client that mimics browsers on the wire
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

use url::Url;

use crate::core::ProxyUrl;
use crate::core::error::Result;

use super::{Device, config};

#[derive(PartialEq, Eq)]
pub(super) struct ProxyKey {
    scheme: String,
    username: String,
    host: Option<String>,
    port: Option<u16>,
}

impl ProxyKey {
    pub(super) fn of(proxy: &ProxyUrl) -> Option<ProxyKey> {
        let url = parse(proxy)?;
        Some(ProxyKey {
            scheme: url.scheme().to_owned(),
            username: url.username().to_owned(),
            host: url.host_str().map(str::to_owned),
            port: url.port_or_known_default(),
        })
    }
}

impl Device {
    pub(super) fn resolved_proxy(&self) -> Result<Option<ProxyUrl>> {
        let (Some(proxy), Some(var)) = (&self.proxy, &self.proxy_password_env) else {
            return Ok(self.proxy.clone());
        };
        let password = std::env::var(var).map_err(|_| {
            config(format!(
                "the proxy password variable {var} is not set or not valid UTF-8"
            ))
        })?;
        let mut url = parse(proxy).ok_or_else(|| config("the device proxy URL is invalid"))?;
        url.set_password(Some(&password))
            .map_err(|()| config("the device proxy URL cannot carry a password"))?;
        ProxyUrl::parse(url.as_str()).map(Some)
    }

    pub(super) fn sanitized(&self) -> Device {
        let mut device = self.clone();
        if device.proxy_password_env.is_some() {
            device.proxy = device.proxy.as_ref().map(strip_password);
        }
        device
    }
}

fn strip_password(proxy: &ProxyUrl) -> ProxyUrl {
    let Some(mut url) = parse(proxy).filter(|url| url.password().is_some()) else {
        return proxy.clone();
    };
    if url.set_password(None).is_err() {
        return proxy.clone();
    }
    ProxyUrl::parse(url.as_str()).unwrap_or_else(|_| proxy.clone())
}

fn parse(proxy: &ProxyUrl) -> Option<Url> {
    Url::parse(&String::from(proxy.clone())).ok()
}