use std::net::{Ipv4Addr, SocketAddr};
use std::sync::{Arc, Mutex};
use std::time::Instant;
use prolink_proto::{DISCOVERY_PORT, MacAddress, djl};
use tokio::net::UdpSocket;
use tokio::sync::broadcast;
use tokio::task::JoinHandle;
use tracing::{debug, trace, warn};
use crate::device::{Device, DeviceEvent, DeviceTable};
use crate::interface::Interface;
use crate::socket::{self, MAX_DATAGRAM};
use crate::{Error, Result};
const EVENT_CAPACITY: usize = 256;
const REAP_INTERVAL: std::time::Duration = std::time::Duration::from_secs(1);
#[derive(Clone, Debug)]
pub struct Announcement {
pub packet: djl::Packet,
pub from: Ipv4Addr,
}
#[derive(Debug)]
pub struct Discovery {
interface: Interface,
socket: Arc<UdpSocket>,
table: Arc<Mutex<DeviceTable>>,
events: broadcast::Sender<DeviceEvent>,
announcements: broadcast::Sender<Announcement>,
tasks: Vec<JoinHandle<()>>,
}
impl Discovery {
#[expect(
clippy::unused_async,
reason = "spawns tasks, so it needs a tokio runtime; async is how that is documented \
at the call site, and keeps the signature stable if setup later awaits"
)]
pub async fn start(interface: Interface) -> Result<Self> {
let socket = Arc::new(socket::bind(DISCOVERY_PORT, Some(&interface))?);
let table = Arc::new(Mutex::new(DeviceTable::new()));
let (events, _) = broadcast::channel(EVENT_CAPACITY);
let (announcements, _) = broadcast::channel(EVENT_CAPACITY);
let mut discovery = Self {
interface,
socket,
table,
events,
announcements,
tasks: Vec::new(),
};
discovery.tasks.push(discovery.spawn_receiver());
discovery.tasks.push(discovery.spawn_reaper());
Ok(discovery)
}
pub fn interface(&self) -> &Interface {
&self.interface
}
pub fn socket(&self) -> Arc<UdpSocket> {
Arc::clone(&self.socket)
}
pub fn devices(&self) -> Vec<Device> {
self.with_table(DeviceTable::all)
}
pub fn online(&self) -> Vec<Device> {
self.with_table(DeviceTable::online)
}
pub fn numbers_seen(&self) -> std::collections::BTreeSet<u8> {
self.with_table(|table| table.numbers_seen().clone())
}
pub fn is_alone(&self) -> bool {
self.with_table(DeviceTable::is_empty)
}
pub fn ignore(&self, mac: MacAddress) {
self.with_table_mut(|table| table.ignore(mac));
}
pub fn subscribe(&self) -> broadcast::Receiver<DeviceEvent> {
self.events.subscribe()
}
pub fn announcements(&self) -> broadcast::Receiver<Announcement> {
self.announcements.subscribe()
}
fn with_table<T>(&self, read: impl FnOnce(&DeviceTable) -> T) -> T {
match self.table.lock() {
Ok(table) => read(&table),
Err(poisoned) => read(&poisoned.into_inner()),
}
}
fn with_table_mut<T>(&self, write: impl FnOnce(&mut DeviceTable) -> T) -> T {
match self.table.lock() {
Ok(mut table) => write(&mut table),
Err(poisoned) => write(&mut poisoned.into_inner()),
}
}
fn spawn_receiver(&self) -> JoinHandle<()> {
let socket = Arc::clone(&self.socket);
let table = Arc::clone(&self.table);
let events = self.events.clone();
let announcements = self.announcements.clone();
tokio::spawn(async move {
let mut buffer = vec![0u8; MAX_DATAGRAM];
loop {
let (len, from) = match socket.recv_from(&mut buffer).await {
Ok(received) => received,
Err(error) => {
warn!(%error, "discovery socket closed");
return;
}
};
let SocketAddr::V4(from) = from else { continue };
let Some(datagram) = buffer.get(..len) else {
continue;
};
let packet = match djl::Packet::decode(datagram) {
Ok(packet) => packet,
Err(error) => {
trace!(%error, bytes = len, "undecodable datagram on 50000");
continue;
}
};
let event = match table.lock() {
Ok(mut table) => table.observe(&packet, Instant::now()),
Err(poisoned) => poisoned.into_inner().observe(&packet, Instant::now()),
};
if let Some(event) = event {
debug!(?event, "device table changed");
let _ = events.send(event);
}
let _ = announcements.send(Announcement {
packet,
from: *from.ip(),
});
}
})
}
fn spawn_reaper(&self) -> JoinHandle<()> {
let table = Arc::clone(&self.table);
let events = self.events.clone();
tokio::spawn(async move {
let mut ticker = tokio::time::interval(REAP_INTERVAL);
loop {
ticker.tick().await;
let expired = match table.lock() {
Ok(mut table) => table.reap(Instant::now()),
Err(poisoned) => poisoned.into_inner().reap(Instant::now()),
};
for event in expired {
debug!(?event, "device timed out");
let _ = events.send(event);
}
}
})
}
}
impl Drop for Discovery {
fn drop(&mut self) {
for task in &self.tasks {
task.abort();
}
}
}
pub async fn scan(interface: Interface, duration: std::time::Duration) -> Result<Vec<Device>> {
let discovery = Discovery::start(interface).await?;
tokio::time::sleep(duration).await;
Ok(discovery.devices())
}
pub const SCAN_DURATION: std::time::Duration = std::time::Duration::from_millis(4500);
impl Discovery {
pub(crate) fn no_browsable_number(&self) -> Error {
Error::NoBrowsableNumber {
taken: self.numbers_seen().into_iter().collect(),
}
}
}