deboa 0.1.5-beta.6

A friendly rest client on top of hyper.
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

//! DNS module for resolving hostnames to IP addresses.
//!
//! This module provides functionality for resolving hostnames to IP addresses.
use http::Version;

use crate::Result;
use std::{future::Future, net::IpAddr};

#[derive(Default, Debug)]
/// DnsResponse builder
pub struct Builder {
    pub(crate) protos: Vec<Version>,
    pub(crate) addrs: Vec<IpAddr>,
}

impl Builder {
    /// Add a list of supported protocols by these servers
    pub fn protos(mut self, protos: Vec<Version>) -> Self {
        self.protos = protos;
        self
    }

    /// Add ip addresses returned
    pub fn addresses(mut self, addrs: Vec<IpAddr>) -> Self {
        self.addrs = addrs;
        self
    }

    /// Build a DnsResponse
    pub fn build(self) -> DnsResponse {
        DnsResponse { protos: self.protos, addrs: self.addrs }
    }
}

#[derive(Default, Debug, Clone)]
/// DNS response type
pub struct DnsResponse {
    pub(crate) protos: Vec<Version>,
    pub(crate) addrs: Vec<IpAddr>,
}

impl DnsResponse {
    /// Create a DnsResponseBuilder
    pub fn builder() -> Builder {
        Builder::default()
    }

    /// Add a list of supported protocols by these servers
    pub fn protos(&self) -> &Vec<Version> {
        &self.protos
    }

    /// Add ip addresses returned
    pub fn addresses(&self) -> &Vec<IpAddr> {
        &self.addrs
    }
}

/// DNS resolver trait for resolving hostnames to IP addresses.
///
/// The returned future is an associated type rather than a boxed
/// `dyn Future + Send`, which is what it used to be. Two reasons:
///
/// - **`Send` was more than a resolver can promise on every runtime.**
///   `getaddrinfo` blocks, so a resolver hands it to a thread pool — and where
///   that pool's handle is itself `!Send`, as glommio's is, the boxed `Send`
///   future was unimplementable. compio's `spawn_blocking` returns a `Send`
///   future and satisfied it; glommio's does not, and had to pull in a second
///   thread pool to work around a bound it could not meet.
/// - It removes an allocation per lookup, which matters less but is free here.
///
/// `impl Future` in trait position matches the style the connection traits in
/// [`crate::conn`] already use.
pub trait DnsResolver: Send + 'static {
    /// Resolves a hostname to a list of IP addresses.
    fn resolve(&self, host: String, port: u16) -> impl Future<Output = Result<DnsResponse>>;
}