#![allow(clippy::module_name_repetitions)]
use std::{
collections::{HashMap, HashSet, VecDeque},
marker::PhantomData,
net::{IpAddr, Ipv4Addr, SocketAddr},
sync::Arc,
time::{Duration, Instant},
};
use bytes::{Bytes, BytesMut};
use parking_lot::RwLock;
use tokio::{net::UdpSocket, task::AbortHandle, time};
use crate::{Decode, Encode, Error, frame::Frame, socket::is_transient_recv_error};
const PROTO_VER: u16 = 2;
const RECV_BUF: usize = 65_536;
const ADVERTISE_ERROR_BACKOFF: Duration = Duration::from_millis(100);
pub const DISCOVERY_PORT: u16 = 7701;
fn fnv1a(bytes: &[u8]) -> u64 {
let mut h: u64 = 14_695_981_039_346_656_037;
for &b in bytes {
h ^= u64::from(b);
h = h.wrapping_mul(1_099_511_628_211);
}
h
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct AppId(u64);
impl AppId {
#[must_use]
pub fn of(name: impl AsRef<str>) -> Self {
Self(fnv1a(name.as_ref().as_bytes()))
}
#[must_use]
pub fn raw(self) -> u64 {
self.0
}
}
impl From<&str> for AppId {
fn from(s: &str) -> Self {
Self::of(s)
}
}
impl From<String> for AppId {
fn from(s: String) -> Self {
Self::of(&s)
}
}
impl From<u64> for AppId {
fn from(v: u64) -> Self {
Self(v)
}
}
pub struct DiscoveryConfig<M = ()> {
pub(crate) app_id: AppId,
pub(crate) data_port: u16,
pub(crate) discovery_port: u16,
pub(crate) probe_interval: Duration,
pub(crate) broadcast_addr: Ipv4Addr,
pub(crate) peer_ttl: Option<Duration>,
pub(crate) probes: ProbePlan,
pub(crate) meta: M,
}
#[derive(Debug, Clone)]
pub(crate) struct ProbePlan {
pub(crate) loopback: bool,
pub(crate) interfaces: bool,
pub(crate) extra: Vec<SocketAddr>,
}
impl Default for ProbePlan {
fn default() -> Self {
Self {
loopback: true,
interfaces: true,
extra: Vec::new(),
}
}
}
impl DiscoveryConfig<()> {
#[must_use]
pub fn new(app_id: impl Into<AppId>, data_port: u16) -> Self {
Self {
app_id: app_id.into(),
data_port,
discovery_port: DISCOVERY_PORT,
probe_interval: Duration::from_secs(5),
broadcast_addr: Ipv4Addr::BROADCAST,
peer_ttl: None,
probes: ProbePlan::default(),
meta: (),
}
}
}
impl<M> DiscoveryConfig<M> {
pub fn meta<N>(self, meta: N) -> DiscoveryConfig<N> {
DiscoveryConfig {
app_id: self.app_id,
data_port: self.data_port,
discovery_port: self.discovery_port,
probe_interval: self.probe_interval,
broadcast_addr: self.broadcast_addr,
peer_ttl: self.peer_ttl,
probes: self.probes,
meta,
}
}
#[must_use]
pub fn discovery_port(mut self, port: u16) -> Self {
self.discovery_port = port;
self
}
#[must_use]
pub fn probe_interval(mut self, interval: Duration) -> Self {
self.probe_interval = interval;
self
}
#[must_use]
pub fn peer_ttl(mut self, ttl: Duration) -> Self {
self.peer_ttl = Some(ttl);
self
}
#[must_use]
pub fn broadcast_addr(mut self, addr: Ipv4Addr) -> Self {
self.broadcast_addr = addr;
self
}
#[must_use]
pub fn probe_loopback(mut self, enabled: bool) -> Self {
self.probes.loopback = enabled;
self
}
#[must_use]
pub fn probe_interfaces(mut self, enabled: bool) -> Self {
self.probes.interfaces = enabled;
self
}
#[must_use]
pub fn probe_targets(mut self, targets: impl IntoIterator<Item = SocketAddr>) -> Self {
self.probes.extra.extend(targets);
self
}
}
impl<A: Into<AppId>> From<(A, u16)> for DiscoveryConfig<()> {
fn from((app_id, data_port): (A, u16)) -> Self {
Self::new(app_id, data_port)
}
}
impl<A: Into<AppId>, M> From<(A, u16, M)> for DiscoveryConfig<M> {
fn from((app_id, data_port, meta): (A, u16, M)) -> Self {
DiscoveryConfig::new(app_id, data_port).meta(meta)
}
}
#[derive(Debug, Clone)]
pub struct DiscoveredPeer<M> {
pub from: SocketAddr,
pub data_addr: SocketAddr,
pub instance: u64,
pub meta: M,
}
pub struct AdvertiseHandle<M> {
meta: Arc<RwLock<M>>,
abort: AbortHandle,
}
impl<M: Send + 'static> AdvertiseHandle<M> {
pub fn set_meta(&self, meta: M) {
*self.meta.write() = meta;
}
}
impl<M> Drop for AdvertiseHandle<M> {
fn drop(&mut self) {
self.abort.abort();
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum DiscoveryEvent<M> {
Found(DiscoveredPeer<M>),
Updated(DiscoveredPeer<M>),
Lost { data_addr: SocketAddr },
ProbeFailed {
target: SocketAddr,
error: Arc<std::io::Error>,
},
}
struct Seen {
last: Instant,
instance: u64,
meta: Bytes,
}
pub struct ScanStream<M> {
socket: Arc<UdpSocket>,
app_id: u64,
broadcast_addr: SocketAddr,
probes: ProbePlan,
ticker: time::Interval,
peer_ttl: Duration,
seen: HashMap<SocketAddr, Seen>,
instances: HashMap<u64, SocketAddr>,
lost: VecDeque<SocketAddr>,
failing: HashSet<SocketAddr>,
failed: VecDeque<(SocketAddr, Arc<std::io::Error>)>,
_phantom: PhantomData<fn() -> M>,
}
impl<M: Decode> ScanStream<M> {
pub async fn next(&mut self) -> Result<DiscoveredPeer<M>, Error> {
loop {
match self.next_event().await? {
DiscoveryEvent::Found(peer) | DiscoveryEvent::Updated(peer) => return Ok(peer),
DiscoveryEvent::Lost { .. } | DiscoveryEvent::ProbeFailed { .. } => {}
}
}
}
pub async fn next_event(&mut self) -> Result<DiscoveryEvent<M>, Error> {
loop {
if let Some((target, error)) = self.failed.pop_front() {
return Ok(DiscoveryEvent::ProbeFailed { target, error });
}
if let Some(data_addr) = self.lost.pop_front() {
return Ok(DiscoveryEvent::Lost { data_addr });
}
let received = tokio::select! {
biased;
result = recv_datagram(&self.socket) => Some(result),
_ = self.ticker.tick() => None,
};
match received {
Some(Ok((buf, from))) => {
if let Ok(frame) = Frame::decode(buf)
&& let Some(event) = self.observe(frame, from)
{
return Ok(event);
}
}
Some(Err(e)) if is_transient_recv_error(&e) => {}
Some(Err(e)) => return Err(e.into()),
None => {
self.expire();
self.probe().await;
}
}
}
}
fn targets(&self) -> Vec<SocketAddr> {
let port = self.broadcast_addr.port();
let mut targets = vec![self.broadcast_addr];
if self.probes.loopback {
targets.push(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port));
}
if self.probes.interfaces {
targets
.extend(interface_broadcasts().map(|addr| SocketAddr::new(IpAddr::V4(addr), port)));
}
targets.extend(self.probes.extra.iter().copied());
let mut seen = HashSet::new();
targets.retain(|target| seen.insert(*target));
targets
}
async fn probe(&mut self) {
let probe = Frame::Probe {
app_id: self.app_id,
proto_ver: PROTO_VER,
}
.encode();
for target in self.targets() {
match self.socket.send_to(&probe, target).await {
Ok(_) => {
self.failing.remove(&target);
}
Err(error) => {
tracing::debug!(target: "zudp::discovery", %target, "probe failed: {error}");
if self.failing.insert(target) {
self.failed.push_back((target, Arc::new(error)));
}
}
}
}
}
fn expire(&mut self) {
let ttl = self.peer_ttl;
let lost = &mut self.lost;
self.seen.retain(|addr, seen| {
let keep = seen.last.elapsed() < ttl;
if !keep {
lost.push_back(*addr);
}
keep
});
let seen = &self.seen;
self.instances.retain(|_, addr| seen.contains_key(addr));
}
fn observe(&mut self, frame: Frame, from: SocketAddr) -> Option<DiscoveryEvent<M>> {
let Frame::Beacon {
app_id,
proto_ver,
data_port,
instance,
meta,
} = frame
else {
return None;
};
if app_id != self.app_id || proto_ver != PROTO_VER {
return None;
}
let data_addr = SocketAddr::new(from.ip(), data_port);
let now = Instant::now();
if let Some(&known) = self.instances.get(&instance)
&& known != data_addr
{
if let Some(seen) = self.seen.get_mut(&known) {
seen.last = now;
}
return None;
}
self.instances.insert(instance, data_addr);
let found = if let Some(seen) = self.seen.get_mut(&data_addr) {
seen.last = now;
if seen.instance == instance && seen.meta == meta {
return None;
}
if seen.instance != instance {
self.instances.remove(&seen.instance);
}
seen.instance = instance;
seen.meta = meta.clone();
false
} else {
self.seen.insert(
data_addr,
Seen {
last: now,
instance,
meta: meta.clone(),
},
);
true
};
let meta = match M::decode_from_bytes(&meta) {
Ok(meta) => meta,
Err(e) => {
tracing::debug!(target: "zudp::discovery", %from, "beacon meta decode failed: {e}");
return None;
}
};
let peer = DiscoveredPeer {
from,
data_addr,
instance,
meta,
};
Some(if found {
DiscoveryEvent::Found(peer)
} else {
DiscoveryEvent::Updated(peer)
})
}
}
pub struct Discovery;
impl Discovery {
#[must_use = "dropping the handle stops advertising"]
pub fn advertise<C, M>(config: C) -> Result<AdvertiseHandle<M>, Error>
where
C: Into<DiscoveryConfig<M>>,
M: Encode + Send + Sync + 'static,
{
let cfg = config.into();
let socket = Arc::new(bind_discovery_socket(cfg.discovery_port)?);
let meta = Arc::new(RwLock::new(cfg.meta));
let meta_arc = meta.clone();
let jh = tokio::spawn(run_advertise(
socket,
cfg.app_id.raw(),
cfg.data_port,
crate::peer::random_u64(),
meta_arc,
));
Ok(AdvertiseHandle {
meta,
abort: jh.abort_handle(),
})
}
pub async fn scan_stream<M>(
config: impl Into<DiscoveryConfig<()>>,
) -> Result<ScanStream<M>, Error>
where
M: Decode,
{
let cfg = config.into();
let socket = Arc::new(bind_discovery_socket(0)?);
let broadcast_addr = SocketAddr::new(IpAddr::V4(cfg.broadcast_addr), cfg.discovery_port);
let mut ticker = time::interval(cfg.probe_interval);
ticker.set_missed_tick_behavior(time::MissedTickBehavior::Skip);
ticker.tick().await;
let mut scan = ScanStream {
socket,
app_id: cfg.app_id.raw(),
broadcast_addr,
probes: cfg.probes,
ticker,
peer_ttl: cfg.peer_ttl.unwrap_or(cfg.probe_interval * 3),
seen: HashMap::new(),
instances: HashMap::new(),
lost: VecDeque::new(),
failing: HashSet::new(),
failed: VecDeque::new(),
_phantom: PhantomData,
};
scan.probe().await;
Ok(scan)
}
pub async fn scan_once<M>(
config: impl Into<DiscoveryConfig<()>>,
timeout: Duration,
) -> Result<Vec<DiscoveredPeer<M>>, Error>
where
M: Decode,
{
let mut scan = Self::scan_stream::<M>(config).await?;
let mut peers = Vec::new();
let mut reported: HashSet<SocketAddr> = HashSet::new();
let deadline = time::Instant::now() + timeout;
loop {
let remaining = deadline.saturating_duration_since(time::Instant::now());
if remaining.is_zero() {
break;
}
match time::timeout(remaining, scan.next()).await {
Err(_elapsed) => break,
Ok(Err(e)) => return Err(e),
Ok(Ok(peer)) => {
if reported.insert(peer.data_addr) {
peers.push(peer);
}
}
}
}
Ok(peers)
}
}
fn bind_discovery_socket(port: u16) -> Result<UdpSocket, Error> {
let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), port);
let sock = socket2::Socket::new(
socket2::Domain::IPV4,
socket2::Type::DGRAM,
Some(socket2::Protocol::UDP),
)?;
#[cfg(unix)]
sock.set_reuse_port(true)?;
sock.set_reuse_address(true)?;
sock.set_broadcast(true)?;
sock.set_nonblocking(true)?;
sock.bind(&socket2::SockAddr::from(addr))?;
#[cfg(windows)]
crate::socket::win::disable_udp_connreset(&sock)?;
let std_sock: std::net::UdpSocket = sock.into();
Ok(UdpSocket::from_std(std_sock)?)
}
async fn recv_datagram(socket: &UdpSocket) -> std::io::Result<(BytesMut, SocketAddr)> {
let mut buf = BytesMut::with_capacity(RECV_BUF);
let (_, addr) = socket.recv_buf_from(&mut buf).await?;
Ok((buf, addr))
}
async fn run_advertise<M: Encode + Send + Sync + 'static>(
socket: Arc<UdpSocket>,
app_id: u64,
data_port: u16,
instance: u64,
meta: Arc<RwLock<M>>,
) {
loop {
let (buf, from) = match recv_datagram(&socket).await {
Ok(pair) => pair,
Err(e) if is_transient_recv_error(&e) => continue,
Err(e) => {
tracing::warn!(target: "zudp::discovery", "recv error: {e}");
time::sleep(ADVERTISE_ERROR_BACKOFF).await;
continue;
}
};
let Ok(frame) = Frame::decode(buf) else {
continue;
};
let Frame::Probe {
app_id: pid,
proto_ver,
} = frame
else {
continue;
};
if pid != app_id || proto_ver != PROTO_VER {
continue;
}
let meta_bytes = match meta.read().encode_to_bytes() {
Ok(b) => Bytes::from(b),
Err(e) => {
tracing::warn!(target: "zudp::discovery", "meta encode error: {e}");
continue;
}
};
let beacon = Frame::Beacon {
app_id,
proto_ver: PROTO_VER,
data_port,
instance,
meta: meta_bytes,
}
.encode();
if let Err(e) = socket.send_to(&beacon, from).await {
tracing::warn!(target: "zudp::discovery", %from, "beacon send failed: {e}");
}
}
}
fn interface_broadcasts() -> impl Iterator<Item = Ipv4Addr> {
if_addrs::get_if_addrs()
.unwrap_or_default()
.into_iter()
.filter(|interface| !interface.is_loopback())
.filter_map(|interface| match interface.addr {
if_addrs::IfAddr::V4(v4) => v4.broadcast,
if_addrs::IfAddr::V6(_) => None,
})
}