use std::net::SocketAddr;
use std::time::Duration;
use tokio::net::TcpStream;
use tokio::time;
use tracing::{debug, trace};
pub const DEFAULT_STAGGER_DELAY: Duration = Duration::from_millis(300);
#[derive(Debug)]
pub struct HappyEyeballsResult {
pub stream: TcpStream,
pub winning_addr: SocketAddr,
pub backup_won: bool,
}
pub async fn connect_with_happy_eyeballs(
primary_addr: SocketAddr,
backup_ipv4: Option<SocketAddr>,
stagger_delay: Duration,
connect_timeout: Duration,
) -> std::io::Result<HappyEyeballsResult> {
let backup = match (backup_ipv4, primary_addr) {
(Some(v4), SocketAddr::V6(_)) => v4,
_ => {
let stream = time::timeout(connect_timeout, TcpStream::connect(primary_addr))
.await
.map_err(|_| {
std::io::Error::new(std::io::ErrorKind::TimedOut, "Connection timed out")
})??;
return Ok(HappyEyeballsResult {
stream,
winning_addr: primary_addr,
backup_won: false,
});
}
};
debug!(
primary = %primary_addr,
backup = %backup,
"Starting Happy Eyeballs dual-stack race"
);
let result = time::timeout(
connect_timeout,
race_primary_and_backup(primary_addr, backup, stagger_delay),
)
.await
.map_err(|_| {
std::io::Error::new(
std::io::ErrorKind::TimedOut,
"Happy Eyeballs connection timed out",
)
})??;
Ok(result)
}
async fn race_primary_and_backup(
primary_addr: SocketAddr,
backup: SocketAddr,
stagger_delay: Duration,
) -> std::io::Result<HappyEyeballsResult> {
let mut primary_fut = std::pin::pin!(TcpStream::connect(primary_addr));
tokio::select! {
res = &mut primary_fut => {
match res {
Ok(stream) => {
debug!(addr = %primary_addr, "Primary IPv6 won before stagger");
Ok(HappyEyeballsResult {
stream,
winning_addr: primary_addr,
backup_won: false,
})
}
Err(e) => {
trace!(error = %e, "Primary IPv6 failed, trying backup IPv4");
match TcpStream::connect(backup).await {
Ok(stream) => {
debug!(addr = %backup,
"Backup IPv4 succeeded after primary failure");
Ok(HappyEyeballsResult {
stream,
winning_addr: backup,
backup_won: true,
})
}
Err(_) => Err(e), }
}
}
}
_ = time::sleep(stagger_delay) => {
debug!("Stagger expired, starting backup IPv4 in parallel with primary");
let mut backup_fut = std::pin::pin!(TcpStream::connect(backup));
tokio::select! {
biased;
res = &mut primary_fut => {
match res {
Ok(stream) => {
debug!(addr = %primary_addr,
"Primary IPv6 won after stagger");
Ok(HappyEyeballsResult {
stream,
winning_addr: primary_addr,
backup_won: false,
})
}
Err(e) => {
trace!(error = %e,
"Primary IPv6 failed in race, waiting for backup");
match (&mut backup_fut).await {
Ok(stream) => {
debug!(addr = %backup,
"Backup IPv4 won after primary failed");
Ok(HappyEyeballsResult {
stream,
winning_addr: backup,
backup_won: true,
})
}
Err(_) => Err(e),
}
}
}
}
res = &mut backup_fut => {
match res {
Ok(stream) => {
debug!(addr = %backup, "Backup IPv4 won the race");
Ok(HappyEyeballsResult {
stream,
winning_addr: backup,
backup_won: true,
})
}
Err(e) => {
trace!(error = %e,
"Backup IPv4 failed in race, waiting for primary");
match (&mut primary_fut).await {
Ok(stream) => {
debug!(addr = %primary_addr,
"Primary IPv6 won after backup failed");
Ok(HappyEyeballsResult {
stream,
winning_addr: primary_addr,
backup_won: false,
})
}
Err(_) => Err(e),
}
}
}
}
}
}
}
}
pub async fn resolve_dual_stack(
host: &str,
port: u16,
) -> std::io::Result<(SocketAddr, Option<SocketAddr>)> {
use tokio::net::lookup_host;
let addr_str = format!("{}:{}", host, port);
let addrs: Vec<SocketAddr> = lookup_host(&addr_str).await?.collect();
if addrs.is_empty() {
return Err(std::io::Error::new(
std::io::ErrorKind::AddrNotAvailable,
format!("No addresses found for {}", host),
));
}
let ipv6 = addrs.iter().find(|a| a.is_ipv6());
let ipv4 = addrs.iter().find(|a| a.is_ipv4());
match (ipv6, ipv4) {
(Some(v6), Some(v4)) => Ok((*v6, Some(*v4))),
(None, Some(v4)) => Ok((*v4, None)),
(Some(v6), None) => Ok((*v6, None)),
(None, None) => Err(std::io::Error::new(
std::io::ErrorKind::AddrNotAvailable,
"No usable addresses found",
)),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_stagger_delay_is_300ms() {
assert_eq!(DEFAULT_STAGGER_DELAY, Duration::from_millis(300));
}
#[tokio::test]
async fn ipv4_primary_no_race() {
let primary: SocketAddr = "127.0.0.1:1".parse().unwrap();
let backup: SocketAddr = "127.0.0.1:2".parse().unwrap();
let result = connect_with_happy_eyeballs(
primary,
Some(backup),
DEFAULT_STAGGER_DELAY,
Duration::from_secs(1),
)
.await;
assert!(result.is_err());
}
#[tokio::test]
async fn resolve_dual_stack_localhost() {
let result = resolve_dual_stack("localhost", 80).await;
if let Ok((primary, backup)) = result {
if primary.is_ipv4() {
assert!(backup.is_none());
}
}
}
}