#![allow(clippy::module_name_repetitions)]
use std::{
collections::HashSet,
marker::PhantomData,
net::{IpAddr, Ipv4Addr, SocketAddr},
sync::Arc,
time::Duration,
};
use bytes::{Bytes, BytesMut};
use parking_lot::RwLock;
use tokio::{net::UdpSocket, task::AbortHandle, time};
use crate::{Decode, Encode, Error, frame::Frame};
const PROTO_VER: u16 = 1;
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) meta: M,
}
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),
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,
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
}
}
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 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();
}
}
pub struct ScanStream<M> {
socket: Arc<UdpSocket>,
app_id: u64,
broadcast_addr: SocketAddr,
ticker: time::Interval,
seen: HashSet<SocketAddr>,
_phantom: PhantomData<fn() -> M>,
}
impl<M: Decode> ScanStream<M> {
pub async fn next(&mut self) -> Result<DiscoveredPeer<M>, Error> {
loop {
tokio::select! {
biased;
result = recv_frame(&self.socket) => {
let (frame, from) = result?;
let Frame::Beacon { app_id, proto_ver, data_port, meta } = frame else {
continue;
};
if app_id != self.app_id || proto_ver != PROTO_VER {
continue;
}
let data_addr = SocketAddr::new(from.ip(), data_port);
if !self.seen.insert(data_addr) {
continue;
}
let meta = M::decode_from_bytes(&meta)?;
return Ok(DiscoveredPeer { from, data_addr, meta });
}
_ = self.ticker.tick() => {
let probe = Frame::Probe {
app_id: self.app_id,
proto_ver: PROTO_VER,
}.encode();
let _ = self.socket.send_to(&probe, self.broadcast_addr).await;
}
}
}
}
}
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,
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(cfg.discovery_port)?);
let broadcast_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::BROADCAST), cfg.discovery_port);
let probe = Frame::Probe {
app_id: cfg.app_id.raw(),
proto_ver: PROTO_VER,
}
.encode();
socket.send_to(&probe, broadcast_addr).await?;
let mut ticker = time::interval(cfg.probe_interval);
ticker.set_missed_tick_behavior(time::MissedTickBehavior::Skip);
ticker.tick().await;
Ok(ScanStream {
socket,
app_id: cfg.app_id.raw(),
broadcast_addr,
ticker,
seen: HashSet::new(),
_phantom: PhantomData,
})
}
pub async fn scan_once<M>(
config: impl Into<DiscoveryConfig<()>>,
timeout: Duration,
) -> Result<Vec<DiscoveredPeer<M>>, Error>
where
M: Decode,
{
let cfg = config.into();
let socket = bind_discovery_socket(cfg.discovery_port)?;
let broadcast_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::BROADCAST), cfg.discovery_port);
let app_id = cfg.app_id.raw();
let probe = Frame::Probe {
app_id,
proto_ver: PROTO_VER,
}
.encode();
socket.send_to(&probe, broadcast_addr).await?;
let mut peers = Vec::new();
let mut seen: 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, recv_frame(&socket)).await {
Err(_elapsed) => break,
Ok(Err(e)) => return Err(e),
Ok(Ok((
Frame::Beacon {
app_id: bid,
proto_ver,
data_port,
meta,
},
from,
))) if bid == app_id && proto_ver == PROTO_VER => {
let data_addr = SocketAddr::new(from.ip(), data_port);
if seen.insert(data_addr) {
let meta = M::decode_from_bytes(&meta)?;
peers.push(DiscoveredPeer {
from,
data_addr,
meta,
});
}
}
Ok(Ok(_)) => {}
}
}
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))?;
let std_sock: std::net::UdpSocket = sock.into();
Ok(UdpSocket::from_std(std_sock)?)
}
async fn recv_frame(socket: &UdpSocket) -> Result<(Frame, SocketAddr), Error> {
let mut buf = BytesMut::with_capacity(65_536);
let (_, addr) = socket.recv_buf_from(&mut buf).await?;
Frame::decode(buf).map(|f| (f, addr))
}
async fn run_advertise<M: Encode + Send + Sync + 'static>(
socket: Arc<UdpSocket>,
app_id: u64,
data_port: u16,
meta: Arc<RwLock<M>>,
) {
loop {
let (frame, from) = match recv_frame(&socket).await {
Ok(pair) => pair,
Err(e) => {
tracing::warn!(target: "zudp::discovery", "recv error: {e}");
break;
}
};
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,
meta: meta_bytes,
}
.encode();
if let Err(e) = socket.send_to(&beacon, from).await {
tracing::warn!(target: "zudp::discovery", %from, "beacon send failed: {e}");
}
}
}