xmppftw/xmpp-rs
Watch
1
0
Fork
You've already forked xmpp-rs
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

happy_eyeballs: migrate to newer trust-dns dependencies

Browse source
This commit is contained in:
Astro 2019-01-17 01:24:26 +01:00
commit 59f433fd21
3 changed files with 34 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Cargo.toml
View file

@ -21,8 +21,8 @@ xml5ever = "0.12"
native-tls = "0.2" native-tls = "0.2"
tokio-tls = "0.2" tokio-tls = "0.2"
sasl = "0.4" sasl = "0.4"
trust-dns-resolver = "0.9.1" trust-dns-resolver = "0.10"
trust-dns-proto = "0.4.0" trust-dns-proto = "0.6"
xmpp-parsers = "0.12.2" xmpp-parsers = "0.12.2"
idna = "0.1" idna = "0.1"
quick-xml = "0.13" quick-xml = "0.13"

10
src/error.rs
View file

@ -107,7 +107,7 @@ pub enum AuthError {
} }
/// Error establishing connection /// Error establishing connection
#[derive(Debug, Error)] #[derive(Debug)]
pub enum ConnecterError { pub enum ConnecterError {
/// All attempts failed, no error available /// All attempts failed, no error available
AllFailed, AllFailed,
@ -116,3 +116,11 @@ pub enum ConnecterError {
/// DNS resolution error /// DNS resolution error
Resolve(ResolveError), Resolve(ResolveError),
} }
impl std::error::Error for ConnecterError {}
impl std::fmt::Display for ConnecterError {
fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
write!(fmt, "{:?}", self)
}
}

56
src/happy_eyeballs.rs
View file

@ -8,17 +8,16 @@ use std::mem;
use std::net::SocketAddr; use std::net::SocketAddr;
use tokio::net::tcp::ConnectFuture; use tokio::net::tcp::ConnectFuture;
use tokio::net::TcpStream; use tokio::net::TcpStream;
use trust_dns_resolver::config::LookupIpStrategy; use trust_dns_resolver::{AsyncResolver, Name, IntoName, Background, BackgroundLookup};
use trust_dns_resolver::lookup::SrvLookupFuture; use trust_dns_resolver::lookup::SrvLookupFuture;
use trust_dns_resolver::lookup_ip::LookupIpFuture; use trust_dns_resolver::lookup_ip::LookupIpFuture;
use trust_dns_resolver::system_conf;
use trust_dns_resolver::{error::ResolveError, IntoName, Name, ResolverFuture};
enum State { enum State {
AwaitResolver(Box<Future<Item = ResolverFuture, Error = ResolveError> + Send>), Start(AsyncResolver),
ResolveSrv(ResolverFuture, SrvLookupFuture), ResolveSrv(AsyncResolver, BackgroundLookup<SrvLookupFuture>),
ResolveTarget(ResolverFuture, LookupIpFuture, u16), ResolveTarget(AsyncResolver, Background<LookupIpFuture>, u16),
Connecting(Option<ResolverFuture>, Vec<RefCell<ConnectFuture>>), Connecting(Option<AsyncResolver>, Vec<RefCell<ConnectFuture>>),
Invalid, Invalid,
} }
@ -31,11 +30,10 @@ pub struct Connecter {
error: Option<Error>, error: Option<Error>,
} }
fn resolver_future( fn resolver() -> Result<AsyncResolver, IoError> {
) -> Result<Box<Future<Item = ResolverFuture, Error = ResolveError> + Send>, IoError> { let (resolver, resolver_background) = AsyncResolver::from_system_conf()?;
let (conf, mut opts) = system_conf::read_system_conf()?; tokio::runtime::current_thread::spawn(resolver_background);
opts.ip_strategy = LookupIpStrategy::Ipv4AndIpv6; Ok(resolver)
Ok(ResolverFuture::new(conf, opts))
} }
impl Connecter { impl Connecter {
@ -57,7 +55,7 @@ impl Connecter {
}); });
} }
let state = State::AwaitResolver(resolver_future()?); let state = State::Start(resolver()?);
let srv_domain = match srv { let srv_domain = match srv {
Some(srv) => Some( Some(srv) => Some(
format!("{}.{}.", srv, domain) format!("{}.{}.", srv, domain)
@ -85,29 +83,21 @@ impl Future for Connecter {
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
let state = mem::replace(&mut self.state, State::Invalid); let state = mem::replace(&mut self.state, State::Invalid);
match state { match state {
State::AwaitResolver(mut resolver_future) => { State::Start(resolver) => {
match resolver_future.poll().map_err(ConnecterError::Resolve)? { match &self.srv_domain {
Async::NotReady => { &Some(ref srv_domain) => {
self.state = State::AwaitResolver(resolver_future); let srv_lookup = resolver.lookup_srv(srv_domain);
Ok(Async::NotReady) self.state = State::ResolveSrv(resolver, srv_lookup);
} }
Async::Ready(resolver) => { None => {
match &self.srv_domain { self.targets = [(self.domain.clone(), self.fallback_port)]
&Some(ref srv_domain) => { .into_iter()
let srv_lookup = resolver.lookup_srv(srv_domain); .cloned()
self.state = State::ResolveSrv(resolver, srv_lookup); .collect();
} self.state = State::Connecting(Some(resolver), vec![]);
None => {
self.targets = [(self.domain.clone(), self.fallback_port)]
.into_iter()
.cloned()
.collect();
self.state = State::Connecting(Some(resolver), vec![]);
}
}
self.poll()
} }
} }
self.poll()
} }
State::ResolveSrv(resolver, mut srv_lookup) => { State::ResolveSrv(resolver, mut srv_lookup) => {
match srv_lookup.poll() { match srv_lookup.poll() {