use std::error::Error as StdError;
use std::fmt;
use std::net::SocketAddr;
use std::task::{Context, Poll};
use futures_util::future::{MapErr, TryFutureExt};
use hyper_util::client::legacy::connect::dns::{GaiResolver, Name};
use tower_service::Service;
pub(crate) type DefaultResolver = ClassifyingResolver<GaiResolver>;
#[derive(Clone)]
pub(crate) struct ClassifyingResolver<R> {
inner: R,
}
impl<R> ClassifyingResolver<R> {
pub(crate) fn new(inner: R) -> Self {
Self { inner }
}
}
#[derive(Debug)]
pub(crate) struct ResolverFailure {
source: Box<dyn StdError + Send + Sync>,
}
impl fmt::Display for ResolverFailure {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("DNS resolution failed")
}
}
impl StdError for ResolverFailure {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
Some(&*self.source)
}
}
fn mark_failure<E>(error: E) -> ResolverFailure
where
E: Into<Box<dyn StdError + Send + Sync>>,
{
ResolverFailure {
source: error.into(),
}
}
impl<R> Service<Name> for ClassifyingResolver<R>
where
R: Service<Name>,
R::Response: Iterator<Item = SocketAddr>,
R::Error: Into<Box<dyn StdError + Send + Sync>>,
{
type Response = R::Response;
type Error = ResolverFailure;
type Future = MapErr<R::Future, fn(R::Error) -> ResolverFailure>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.inner.poll_ready(cx).map_err(mark_failure::<R::Error>)
}
fn call(&mut self, name: Name) -> Self::Future {
self.inner.call(name).map_err(mark_failure::<R::Error>)
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::future::{ready, Ready};
use std::io;
use std::net::{IpAddr, Ipv4Addr};
#[derive(Clone)]
struct StaticResolver(Vec<SocketAddr>);
impl Service<Name> for StaticResolver {
type Response = std::vec::IntoIter<SocketAddr>;
type Error = io::Error;
type Future = Ready<Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, _: Name) -> Self::Future {
ready(Ok(self.0.clone().into_iter()))
}
}
#[derive(Clone, Copy)]
struct FailingResolver;
impl Service<Name> for FailingResolver {
type Response = std::vec::IntoIter<SocketAddr>;
type Error = io::Error;
type Future = Ready<Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, _: Name) -> Self::Future {
ready(Err(io::Error::new(
io::ErrorKind::NotFound,
"synthetic resolver failure",
)))
}
}
#[derive(Clone, Copy)]
struct ReadinessFailingResolver;
impl Service<Name> for ReadinessFailingResolver {
type Response = std::vec::IntoIter<SocketAddr>;
type Error = io::Error;
type Future = Ready<Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Err(io::Error::other(
"synthetic resolver readiness failure",
)))
}
fn call(&mut self, _: Name) -> Self::Future {
ready(Ok(Vec::new().into_iter()))
}
}
fn test_name() -> Name {
"synthetic.example".parse().expect("test name is valid")
}
#[tokio::test]
async fn success_preserves_resolver_address_order() {
let addresses = vec![
SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 8080),
SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 8081),
];
let mut resolver = ClassifyingResolver::new(StaticResolver(addresses.clone()));
let result = resolver
.call(test_name())
.await
.unwrap()
.collect::<Vec<_>>();
assert_eq!(result, addresses);
}
#[tokio::test]
async fn call_failure_marks_and_preserves_original_source() {
let mut resolver = ClassifyingResolver::new(FailingResolver);
let error = resolver
.call(test_name())
.await
.expect_err("resolver should fail");
assert_eq!(error.to_string(), "DNS resolution failed");
let source = error
.source()
.expect("original resolver error is preserved");
assert_eq!(
source.downcast_ref::<io::Error>().unwrap().kind(),
io::ErrorKind::NotFound
);
}
#[test]
fn readiness_failure_uses_the_same_marker() {
let mut resolver = ClassifyingResolver::new(ReadinessFailingResolver);
let mut context = Context::from_waker(futures_util::task::noop_waker_ref());
let Poll::Ready(result) = resolver.poll_ready(&mut context) else {
panic!("poll should be ready");
};
let error = result.expect_err("resolver should fail readiness");
assert_eq!(error.to_string(), "DNS resolution failed");
assert_eq!(
error
.source()
.expect("original readiness error is preserved")
.downcast_ref::<io::Error>()
.unwrap()
.kind(),
io::ErrorKind::Other
);
}
}