use std::collections::BTreeMap;
use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
use std::sync::atomic::{AtomicBool, AtomicU8, AtomicU32, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use prolink_proto::djl::{self, Body};
use prolink_proto::status::{self, CdjStatus, MediaState};
use prolink_proto::{
BEAT_PORT, BrowsableDeviceNumber, DISCOVERY_PORT, DeviceKind, DeviceName, DeviceNumber,
STATUS_PORT, Slot,
};
use tokio::net::UdpSocket;
use tokio::sync::{broadcast, watch};
use tokio::task::JoinHandle;
use tracing::{debug, info, warn};
use crate::discovery::Discovery;
use crate::media::{MediaDescription, MediaSource, NoMedia};
use crate::playback::{BeatPosition, Playback, PlaybackCell};
use crate::socket::{self, MAX_DATAGRAM};
use crate::{Error, Result};
pub const PRESCAN: Duration = Duration::from_millis(2500);
const MEDIA_POLL: Duration = Duration::from_millis(10);
pub const OBSERVER_NUMBER: DeviceNumber = match DeviceNumber::new(7) {
Some(number) => number,
None => DeviceNumber::ONE,
};
const BEAT_TICK: Duration = Duration::from_millis(5);
const STATUS_CHECK: Duration = Duration::from_millis(5);
const STATUS_FLOOR: Duration = Duration::from_millis(62);
const FIRST_ON_NETWORK: u8 = 0x02;
const JOINED_PEERS: u8 = 0x01;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Numbering {
Claim {
preferred: Option<BrowsableDeviceNumber>,
},
Observer(DeviceNumber),
}
impl Default for Numbering {
fn default() -> Self {
Self::Observer(OBSERVER_NUMBER)
}
}
#[derive(Clone, Debug)]
pub struct VirtualCdjConfig {
pub name: DeviceName,
pub kind: DeviceKind,
pub numbering: Numbering,
pub generation: u8,
pub firmware: String,
pub emit_status: bool,
}
impl Default for VirtualCdjConfig {
fn default() -> Self {
Self {
name: DeviceName::default(),
kind: DeviceKind::CDJ,
numbering: Numbering::default(),
generation: 0x00,
firmware: "1.44".to_owned(),
emit_status: true,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Phase {
Watching,
Claiming,
Announcing,
Failed,
}
#[derive(Debug, Default)]
pub struct LoadedTracks {
by_device: Mutex<BTreeMap<(u8, Slot), u32>>,
}
impl LoadedTracks {
pub fn note(&self, device: u8, slot: Slot, track: u32) {
let Ok(mut loaded) = self.by_device.lock() else {
return;
};
if track == 0 {
loaded.remove(&(device, slot));
} else {
loaded.insert((device, slot), track);
}
}
pub fn forget(&self, device: u8) {
if let Ok(mut loaded) = self.by_device.lock() {
loaded.retain(|(had, _), _| *had != device);
}
}
pub fn consumers(&self) -> Vec<(u8, Slot, u32)> {
self.by_device.lock().map_or_else(
|_| Vec::new(),
|loaded| {
loaded
.iter()
.map(|((device, slot), track)| (*device, *slot, *track))
.collect()
},
)
}
pub fn track_on(&self, device: u8, slot: Slot) -> Option<u32> {
self.by_device.lock().ok()?.get(&(device, slot)).copied()
}
}
#[derive(Clone, Debug)]
pub struct PeerSlot {
pub device: DeviceNumber,
pub slot: Slot,
pub state: MediaState,
pub description: Option<MediaDescription>,
}
impl PeerSlot {
pub fn has_media(&self) -> bool {
self.state.has_media()
}
pub fn volume_name(&self) -> &str {
self.description
.as_ref()
.map_or("", |description| description.volume_name.as_str())
}
pub fn track_count(&self) -> Option<u32> {
Some(self.description.as_ref()?.track_count)
}
pub fn playlist_count(&self) -> Option<u32> {
Some(self.description.as_ref()?.playlist_count)
}
}
#[derive(Debug, Default)]
pub struct PeerMedia {
slots: Mutex<BTreeMap<(u8, Slot), PeerSlot>>,
}
impl PeerMedia {
pub fn all(&self) -> Vec<PeerSlot> {
self.with(|slots| slots.values().cloned().collect())
}
pub fn of(&self, device: DeviceNumber) -> Vec<PeerSlot> {
self.with(|slots| {
slots
.values()
.filter(|entry| entry.device == device)
.cloned()
.collect()
})
}
pub fn get(&self, device: DeviceNumber, slot: Slot) -> Option<PeerSlot> {
self.with(|slots| slots.get(&(device.get(), slot)).cloned())
}
pub fn occupied(&self) -> Vec<PeerSlot> {
self.with(|slots| {
slots
.values()
.filter(|entry| entry.has_media())
.cloned()
.collect()
})
}
fn note_state(&self, device: DeviceNumber, slot: Slot, state: MediaState) {
self.entry(device, slot, |entry| {
if state == MediaState::EMPTY {
entry.description = None;
}
entry.state = state;
});
}
fn note_description(&self, device: DeviceNumber, slot: Slot, description: &MediaDescription) {
self.entry(device, slot, |entry| {
entry.description = Some(description.clone());
});
}
fn entry(&self, device: DeviceNumber, slot: Slot, update: impl FnOnce(&mut PeerSlot)) {
let Ok(mut slots) = self.slots.lock() else {
return;
};
let entry = slots.entry((device.get(), slot)).or_insert(PeerSlot {
device,
slot,
state: MediaState::EMPTY,
description: None,
});
update(entry);
}
fn with<T>(&self, read: impl FnOnce(&BTreeMap<(u8, Slot), PeerSlot>) -> T) -> T {
match self.slots.lock() {
Ok(slots) => read(&slots),
Err(poisoned) => read(&poisoned.into_inner()),
}
}
}
#[derive(Debug)]
pub struct VirtualCdj {
config: VirtualCdjConfig,
interface: crate::Interface,
number: Arc<AtomicU8>,
phase: watch::Sender<Phase>,
media: Arc<dyn MediaSource>,
loaded: Arc<LoadedTracks>,
peers: Arc<PeerMedia>,
status_socket: Option<Arc<UdpSocket>>,
status_tap: Option<broadcast::Sender<Arc<Vec<u8>>>>,
status_counter: Arc<AtomicU32>,
playback: Arc<PlaybackCell>,
playing_track: Arc<Mutex<Option<status::LoadedTrack>>>,
tempo_master: Arc<AtomicBool>,
yielding_to: Arc<AtomicU8>,
synced: Arc<AtomicBool>,
first_on_network: Arc<AtomicBool>,
tasks: Vec<JoinHandle<()>>,
}
const TAP_CAPACITY: usize = 64;
impl VirtualCdj {
pub async fn start(
discovery: &Discovery,
config: VirtualCdjConfig,
media: Arc<dyn MediaSource>,
) -> Result<Self> {
let interface = discovery.interface().clone();
discovery.ignore(interface.mac);
let was_first = discovery.is_alone();
info!(
first_on_network = was_first,
peers = discovery.devices().len(),
"starting virtual CDJ"
);
let (phase, _) = watch::channel(Phase::Watching);
let (number, answered) = match config.numbering {
Numbering::Observer(number) => (number, false),
Numbering::Claim { preferred } => {
match claim(discovery, &config, &interface, preferred, was_first, &phase).await {
Ok(claimed) => claimed,
Err(error) => {
let _ = phase.send(Phase::Failed);
return Err(error);
}
}
}
};
let _ = phase.send(Phase::Announcing);
if answered {
info!("a player holding the first-on-network role answered our claim; not taking it");
}
let status_socket = if config.emit_status {
Some(Arc::new(socket::bind(STATUS_PORT, Some(&interface))?))
} else {
None
};
let status_tap = status_socket
.as_ref()
.map(|_| broadcast::Sender::new(TAP_CAPACITY));
let mut cdj = Self {
config,
interface,
number: Arc::new(AtomicU8::new(number.get())),
phase,
media,
loaded: Arc::new(LoadedTracks::default()),
peers: Arc::new(PeerMedia::default()),
status_socket,
status_tap,
status_counter: Arc::new(AtomicU32::new(0)),
playback: Arc::new(PlaybackCell::default()),
playing_track: Arc::new(Mutex::new(None)),
tempo_master: Arc::new(AtomicBool::new(false)),
yielding_to: Arc::new(AtomicU8::new(0)),
synced: Arc::new(AtomicBool::new(false)),
first_on_network: Arc::new(AtomicBool::new(was_first && !answered)),
tasks: Vec::new(),
};
cdj.tasks.push(cdj.spawn_keep_alive(discovery));
cdj.tasks.push(cdj.spawn_defender(discovery));
cdj.tasks.push(cdj.spawn_step_aside(discovery));
if let Some(socket) = cdj.status_socket.clone() {
cdj.tasks.push(cdj.spawn_status(discovery)?);
cdj.tasks.push(cdj.spawn_query_responder(socket));
cdj.tasks.push(cdj.spawn_beats()?);
}
Ok(cdj)
}
pub async fn observe(discovery: &Discovery, config: VirtualCdjConfig) -> Result<Self> {
Self::start(discovery, config, Arc::new(NoMedia)).await
}
pub fn number(&self) -> DeviceNumber {
DeviceNumber::new(self.number.load(Ordering::Relaxed)).unwrap_or(OBSERVER_NUMBER)
}
pub fn status_datagrams(&self) -> Option<broadcast::Receiver<Arc<Vec<u8>>>> {
self.status_tap.as_ref().map(broadcast::Sender::subscribe)
}
pub fn browsable_number(&self) -> Option<BrowsableDeviceNumber> {
self.number().browsable()
}
pub fn loaded(&self) -> Arc<LoadedTracks> {
Arc::clone(&self.loaded)
}
pub fn peer_media(&self) -> Arc<PeerMedia> {
Arc::clone(&self.peers)
}
pub fn phase(&self) -> watch::Receiver<Phase> {
self.phase.subscribe()
}
pub fn set_playback(&self, playback: Playback) {
self.playback.set(playback);
}
pub fn clear_playback(&self) {
self.playback.clear();
}
pub fn set_loaded_track(&self, track: Option<status::LoadedTrack>) {
match self.playing_track.lock() {
Ok(mut held) => *held = track,
Err(poisoned) => *poisoned.into_inner() = track,
}
}
#[must_use]
pub fn loaded_track(&self) -> Option<status::LoadedTrack> {
match self.playing_track.lock() {
Ok(held) => *held,
Err(poisoned) => *poisoned.into_inner(),
}
}
pub fn playback(&self) -> Playback {
self.playback.now()
}
pub fn set_tempo_master(&self, master: bool) {
self.yielding_to.store(0, Ordering::Relaxed);
self.tempo_master.store(master, Ordering::Relaxed);
}
pub fn set_synced(&self, synced: bool) {
self.synced.store(synced, Ordering::Relaxed);
}
pub fn is_tempo_master(&self) -> bool {
self.tempo_master.load(Ordering::Relaxed)
}
pub fn first_on_network(&self) -> bool {
self.first_on_network.load(Ordering::Relaxed)
}
pub fn yield_tempo_master(&self, requester: DeviceNumber, address: Ipv4Addr) -> Result<()> {
if !self.is_tempo_master() {
return Ok(());
}
let response = prolink_proto::beat::MasterResponse {
name: self.config.name,
device: self.number(),
granted: true,
};
let to = SocketAddr::V4(SocketAddrV4::new(address, BEAT_PORT));
socket::send_once(&self.interface, to, &response.encode())?;
self.yielding_to.store(requester.get(), Ordering::Relaxed);
info!(%requester, "granted tempo master; naming it as successor");
Ok(())
}
pub fn yielding_to(&self) -> Option<DeviceNumber> {
DeviceNumber::new(self.yielding_to.load(Ordering::Relaxed))
}
pub fn offer_tempo_master(&self, successor: DeviceNumber) -> bool {
if !self.is_tempo_master() {
return false;
}
if self
.yielding_to
.compare_exchange(0, successor.get(), Ordering::AcqRel, Ordering::Relaxed)
.is_err()
{
return false;
}
info!(%successor, "offering tempo master");
true
}
pub fn withdraw_offer(&self) {
self.yielding_to.store(0, Ordering::Relaxed);
}
pub fn finish_yield(&self) {
self.yielding_to.store(0, Ordering::Relaxed);
self.set_tempo_master(false);
}
pub fn request_tempo_master(&self, holder: Ipv4Addr) -> Result<()> {
let request = prolink_proto::beat::MasterRequest {
name: self.config.name,
device: self.number(),
};
let to = SocketAddr::V4(SocketAddrV4::new(holder, BEAT_PORT));
socket::send_once(&self.interface, to, &request.encode())?;
info!(%holder, "asked the tempo master to hand over");
Ok(())
}
pub async fn survey_media(
&self,
discovery: &Discovery,
wait: Duration,
) -> Result<Vec<PeerSlot>> {
let ours = self.number();
let mut asked = 0usize;
for device in discovery.online() {
if device.number == ours {
continue;
}
for slot in [Slot::USB, Slot::SD] {
self.send_media_query(device.ip, device.number, slot)
.await?;
asked += 1;
}
}
debug!(queries = asked, "asked our peers what is in their slots");
if asked > 0 {
tokio::time::sleep(wait).await;
}
Ok(self.peers.all())
}
pub async fn query_media(
&self,
peer: Ipv4Addr,
target: DeviceNumber,
slot: Slot,
wait: Duration,
) -> Result<MediaDescription> {
self.send_media_query(peer, target, slot).await?;
let deadline = tokio::time::Instant::now() + wait;
while tokio::time::Instant::now() < deadline {
if let Some(entry) = self.peers.get(target, slot)
&& let Some(description) = entry.description
{
return Ok(description);
}
tokio::time::sleep(MEDIA_POLL).await;
}
Err(Error::Timeout {
what: "a media query",
after: wait,
})
}
pub async fn ask_media(&self, peer: Ipv4Addr, target: DeviceNumber, slot: Slot) -> Result<()> {
self.send_media_query(peer, target, slot).await
}
async fn send_media_query(
&self,
peer: Ipv4Addr,
target: DeviceNumber,
slot: Slot,
) -> Result<()> {
let Some(socket) = self.status_socket.as_ref() else {
return Err(Error::NoStatusPort { port: STATUS_PORT });
};
let query = status::MediaQuery {
requester: self.number(),
requester_ip: self.interface.ip,
target,
slot,
};
let to = SocketAddr::V4(SocketAddrV4::new(peer, STATUS_PORT));
socket
.send_to(&query.encode(self.config.name), to)
.await
.map_err(Error::io("asking a peer about a slot"))?;
Ok(())
}
pub fn status_packet(&self, peers: usize) -> CdjStatus {
status_packet(
&self.config,
&self.number,
self.media.as_ref(),
&self.status_counter,
peers,
Transport {
playback: &self.playback.now(),
loaded: self.loaded_track(),
tempo_master: self.is_tempo_master(),
yielding_to: self.yielding_to(),
synced: self.synced.load(Ordering::Relaxed),
},
)
}
pub fn keep_alive(&self, peers: usize, was_first: bool) -> djl::Packet {
djl::Packet::new(
self.config.name,
self.config.kind,
Body::KeepAlive {
device_number: self.number().get(),
was_first_on_network: if was_first {
FIRST_ON_NETWORK
} else {
JOINED_PEERS
},
mac: self.interface.mac,
ip: self.interface.ip,
peer_count: u8::try_from(peers.saturating_add(1)).unwrap_or(u8::MAX),
pad_31: [0; 3],
flags: self.config.kind.role(),
trailing: self.config.generation,
},
)
}
fn spawn_keep_alive(&self, discovery: &Discovery) -> JoinHandle<()> {
let socket = discovery.socket();
let broadcast = SocketAddr::V4(SocketAddrV4::new(
self.interface.broadcast(),
DISCOVERY_PORT,
));
let first_on_network = Arc::clone(&self.first_on_network);
let config = self.config.clone();
let interface = self.interface.clone();
let number = Arc::clone(&self.number);
let peers = PeerAddresses::new(discovery);
tokio::spawn(async move {
let mut ticker = tokio::time::interval(djl::KEEPALIVE_INTERVAL);
loop {
ticker.tick().await;
let packet = keep_alive_packet(
&config,
&interface,
&number,
peers.len(),
first_on_network.load(Ordering::Relaxed),
);
if let Err(error) = socket.send_to(&packet.encode(), broadcast).await {
warn!(%error, "keep-alive failed");
}
}
})
}
fn spawn_step_aside(&self, discovery: &Discovery) -> JoinHandle<()> {
let mut announcements = discovery.announcements();
let first_on_network = Arc::clone(&self.first_on_network);
let ours = self.interface.mac;
tokio::spawn(async move {
loop {
let announcement = match announcements.recv().await {
Ok(announcement) => announcement,
Err(broadcast::error::RecvError::Lagged(_)) => continue,
Err(broadcast::error::RecvError::Closed) => return,
};
if !first_on_network.load(Ordering::Relaxed) {
return;
}
if steps_aside(&announcement, ours) {
first_on_network.store(false, Ordering::Relaxed);
info!(
holder = %announcement.from,
"another device says it was first on the network; stepping aside"
);
return;
}
}
})
}
fn spawn_status(&self, discovery: &Discovery) -> Result<JoinHandle<()>> {
let socket = socket::bind_at(self.interface.ip, 0, Some(&self.interface))?;
let config = self.config.clone();
let number = Arc::clone(&self.number);
let media = Arc::clone(&self.media);
let counter = Arc::clone(&self.status_counter);
let table = PeerAddresses::new(discovery);
let playback = Arc::clone(&self.playback);
let playing_track = Arc::clone(&self.playing_track);
let master = Arc::clone(&self.tempo_master);
let yielding = Arc::clone(&self.yielding_to);
let synced = Arc::clone(&self.synced);
Ok(tokio::spawn(async move {
let mut check = tokio::time::interval(STATUS_CHECK);
check.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
let mut last: Option<(Instant, Published)> = None;
loop {
check.tick().await;
let playing_now = playback.now();
let transport = Transport {
playback: &playing_now,
loaded: playing_track.lock().ok().and_then(|held| *held),
tempo_master: master.load(Ordering::Relaxed),
yielding_to: DeviceNumber::new(yielding.load(Ordering::Relaxed)),
synced: synced.load(Ordering::Relaxed),
};
let published = Published::of(&transport, media.as_ref());
let now = Instant::now();
if !status_due(last, now, published) {
continue;
}
let peers = table.get();
let packet = status_packet(
&config,
&number,
media.as_ref(),
&counter,
peers.len(),
transport,
);
counter.fetch_add(1, Ordering::Relaxed);
for peer in peers {
let to = SocketAddr::V4(SocketAddrV4::new(peer, STATUS_PORT));
if let Err(error) = socket.send_to(packet.as_bytes(), to).await {
debug!(%error, %peer, "status unicast failed");
}
}
last = Some((now, published));
}
}))
}
fn spawn_beats(&self) -> Result<JoinHandle<()>> {
let socket = socket::bind_at(self.interface.ip, 0, Some(&self.interface))?;
let broadcast = SocketAddr::V4(SocketAddrV4::new(self.interface.broadcast(), BEAT_PORT));
let name = self.config.name;
let number = Arc::clone(&self.number);
let playback = Arc::clone(&self.playback);
Ok(tokio::spawn(async move {
let mut ticker = tokio::time::interval(BEAT_TICK);
let mut emitted: Option<u32> = None;
loop {
ticker.tick().await;
let now = playback.now();
let Some(position) = beat_to_emit(&now, &mut emitted) else {
continue;
};
let Some(device) = DeviceNumber::new(number.load(Ordering::Relaxed)) else {
continue;
};
let Some(packet) = now.beat_packet(device, name, position) else {
continue;
};
if let Err(error) = socket.send_to(&packet.encode(), broadcast).await {
debug!(%error, "beat broadcast failed");
}
}
}))
}
fn spawn_query_responder(&self, socket: Arc<UdpSocket>) -> JoinHandle<()> {
let name = self.config.name;
let number = Arc::clone(&self.number);
let media = Arc::clone(&self.media);
let loaded = Arc::clone(&self.loaded);
let peers = Arc::clone(&self.peers);
let tap = self.status_tap.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, "status socket closed");
return;
}
};
let SocketAddr::V4(from) = from else { continue };
let Some(datagram) = buffer.get(..len) else {
continue;
};
let Some(ours) = DeviceNumber::new(number.load(Ordering::Relaxed)) else {
continue;
};
if let Some(tap) = tap.as_ref()
&& tap.receiver_count() > 0
{
let _ = tap.send(Arc::new(datagram.to_vec()));
}
let reply = match status::decode(datagram) {
Ok(status::Packet::CdjStatus(peer)) => {
observe_loaded(&loaded, ours, &peer);
observe_peer_slots(&peers, &peer);
None
}
Ok(status::Packet::MediaResponse(response)) => {
observe_peer_media(&peers, &response);
None
}
Ok(status::Packet::MediaQuery(query)) => {
answer_media_query(query, ours, name, media.as_ref())
.map(|reply| (reply, query.requester_ip))
}
Ok(status::Packet::SettingsQuery(query)) => {
let settings = media.settings(query.slot);
let response = status::SettingsResponse::build(
name,
ours,
query.requester,
query.slot,
&settings,
);
info!(slot = %query.slot, bytes = settings.len(), "answered a settings query");
Some((response.into_bytes(), *from.ip()))
}
_ => None,
};
if let Some((datagram, to)) = reply {
let to = SocketAddr::V4(SocketAddrV4::new(to, STATUS_PORT));
if let Err(error) = socket.send_to(&datagram, to).await {
warn!(%error, "could not answer a query");
}
}
}
})
}
fn spawn_defender(&self, discovery: &Discovery) -> JoinHandle<()> {
let mut announcements = discovery.announcements();
let socket = discovery.socket();
let config = self.config.clone();
let interface = self.interface.clone();
let number = Arc::clone(&self.number);
tokio::spawn(async move {
loop {
let Ok(announcement) = announcements.recv().await else {
return;
};
let ours = number.load(Ordering::Relaxed);
let (Body::ClaimIp {
device_number: proposed,
..
}
| Body::ClaimNumber {
device_number: proposed,
..
}) = announcement.packet.body
else {
continue;
};
if proposed != ours || announcement.packet.body.mac() == Some(interface.mac) {
continue;
}
info!(number = ours, challenger = %announcement.from, "defending our device number");
let packet = djl::Packet::new(
config.name,
config.kind,
Body::NumberConflict {
device_number: ours,
ip: interface.ip,
},
);
let to = SocketAddr::V4(SocketAddrV4::new(announcement.from, DISCOVERY_PORT));
if let Err(error) = socket.send_to(&packet.encode(), to).await {
warn!(%error, "could not defend our number");
}
}
})
}
}
impl Drop for VirtualCdj {
fn drop(&mut self) {
for task in &self.tasks {
task.abort();
}
}
}
fn answer_media_query(
query: status::MediaQuery,
ours: DeviceNumber,
name: DeviceName,
media: &dyn MediaSource,
) -> Option<Vec<u8>> {
if query.target != ours {
return None;
}
let description = media.describe(query.slot)?;
info!(
requester = %query.requester,
slot = %query.slot,
tracks = description.track_count,
playlists = description.playlist_count,
"answered a media query",
);
let mut builder = status::MediaResponse::builder()
.device_number(ours)
.slot(query.slot)
.name(name)
.volume_name(&description.volume_name)
.counts(description.track_count, description.playlist_count)
.plain(description.plain);
if let (Some(total), Some(free)) = (description.total_bytes, description.free_bytes) {
builder = builder.size(total, free);
}
Some(builder.build().into_bytes())
}
fn keep_alive_packet(
config: &VirtualCdjConfig,
interface: &crate::Interface,
number: &AtomicU8,
peers: usize,
was_first: bool,
) -> djl::Packet {
djl::Packet::new(
config.name,
config.kind,
Body::KeepAlive {
device_number: number.load(Ordering::Relaxed),
was_first_on_network: if was_first {
FIRST_ON_NETWORK
} else {
JOINED_PEERS
},
mac: interface.mac,
ip: interface.ip,
peer_count: u8::try_from(peers.saturating_add(1)).unwrap_or(u8::MAX),
pad_31: [0; 3],
flags: config.kind.role(),
trailing: config.generation,
},
)
}
fn observe_loaded(loaded: &LoadedTracks, ours: DeviceNumber, peer: &CdjStatus) {
let Some(device) = peer.sender() else {
return;
};
if peer.source_player() != Some(ours) {
return;
}
loaded.note(device.get(), peer.source_slot(), peer.track_id());
}
fn observe_peer_slots(peers: &PeerMedia, peer: &CdjStatus) {
let Some(device) = peer.sender() else {
return;
};
for slot in [Slot::USB, Slot::SD] {
if let Some(state) = peer.slot_state(slot) {
peers.note_state(device, slot, state);
}
}
}
fn observe_peer_media(peers: &PeerMedia, response: &status::MediaResponse) {
let Some(device) = response.device() else {
return;
};
let slot = response.slot();
let description = MediaDescription {
volume_name: response.volume_name(),
created: response.created(),
track_count: response.track_count(),
playlist_count: response.playlist_count(),
total_bytes: response.total_bytes(),
free_bytes: response.free_bytes(),
plain: response.is_plain(),
};
debug!(
%device,
%slot,
tracks = description.track_count,
playlists = description.playlist_count,
volume = description.volume_name,
"a peer described one of its slots",
);
peers.note_description(device, slot, &description);
}
fn beat_to_emit(playback: &Playback, emitted: &mut Option<u32>) -> Option<BeatPosition> {
if playback.scratching {
*emitted = None;
return None;
}
let (Some(position), true) = (playback.beat, playback.playing) else {
*emitted = None;
return None;
};
let previous = emitted.replace(position.number);
if previous == Some(position.number) {
return None;
}
let late = playback
.beat_interval()
.map(|interval| interval.mul_f64(position.fraction.clamp(0.0, 1.0)));
late.is_some_and(|late| late <= 2 * BEAT_TICK)
.then_some(BeatPosition {
number: position.number,
fraction: 0.0,
})
}
#[derive(Clone, Copy, Debug)]
struct Transport<'a> {
playback: &'a Playback,
loaded: Option<status::LoadedTrack>,
tempo_master: bool,
yielding_to: Option<DeviceNumber>,
synced: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
struct Published {
tempo_master: bool,
yielding_to: Option<DeviceNumber>,
synced: bool,
playing: bool,
play_state: u8,
loaded: Option<status::LoadedTrack>,
usb: MediaState,
sd: MediaState,
}
impl Published {
fn of(transport: &Transport<'_>, media: &dyn MediaSource) -> Self {
Self {
tempo_master: transport.tempo_master,
yielding_to: transport.yielding_to,
synced: transport.synced,
playing: transport.playback.playing,
play_state: play_state_for(transport.playback).0,
loaded: transport.loaded,
usb: media.slot_state(Slot::USB),
sd: media.slot_state(Slot::SD),
}
}
}
fn status_due(last: Option<(Instant, Published)>, now: Instant, published: Published) -> bool {
let Some((sent, said)) = last else {
return true;
};
let since = now.saturating_duration_since(sent);
since >= status::STATUS_INTERVAL || (published != said && since >= STATUS_FLOOR)
}
fn status_packet(
config: &VirtualCdjConfig,
number: &AtomicU8,
media: &dyn MediaSource,
counter: &AtomicU32,
peers: usize,
transport: Transport<'_>,
) -> CdjStatus {
let Transport {
playback,
loaded,
tempo_master,
yielding_to,
synced,
} = transport;
let occupied = media.occupied_slots();
let state = |slot: Slot| media.slot_state(slot);
let mut builder = CdjStatus::builder()
.name(config.name)
.slot_state(Slot::USB, state(Slot::USB))
.slot_state(Slot::SD, state(Slot::SD))
.link_available(!occupied.is_empty() || peers > 0)
.firmware(&config.firmware)
.packet_counter(counter.load(Ordering::Relaxed))
.tempo(playback.bpm_centi, playback.pitch)
.loaded_track(loaded)
.playing(playback.playing)
.tempo_master(tempo_master)
.yielding_to(yielding_to)
.synced(synced)
.beat(
playback.beat.map(|beat| beat.number),
playback.beat.map(BeatPosition::in_bar),
)
.play_state(play_state_for(playback).0);
if let Some(number) = DeviceNumber::new(number.load(Ordering::Relaxed)) {
builder = builder.device_number(number);
}
builder.build()
}
fn play_state_for(playback: &Playback) -> crate::monitor::PlayState {
use crate::monitor::PlayState;
if playback.bpm_centi.is_none() {
PlayState::NO_TRACK
} else if playback.playing {
PlayState::PLAYING
} else {
PlayState::PAUSED
}
}
async fn claim(
discovery: &Discovery,
config: &VirtualCdjConfig,
interface: &crate::Interface,
preferred: Option<BrowsableDeviceNumber>,
was_first: bool,
phase: &watch::Sender<Phase>,
) -> Result<(DeviceNumber, bool)> {
debug!(?preferred, "watching before claiming");
let _ = phase.send(Phase::Watching);
tokio::time::sleep(PRESCAN).await;
let seen = discovery.numbers_seen();
let mut candidates: Vec<BrowsableDeviceNumber> = preferred
.into_iter()
.chain(BrowsableDeviceNumber::descending())
.filter(|number| !seen.contains(&number.get()))
.collect();
candidates.dedup();
if candidates.is_empty() {
return Err(discovery.no_browsable_number());
}
let socket = discovery.socket();
let to = SocketAddr::V4(SocketAddrV4::new(interface.broadcast(), DISCOVERY_PORT));
let _ = phase.send(Phase::Claiming);
for candidate in candidates {
let mut conflicts = discovery.announcements();
match claim_one(
&socket,
to,
config,
interface,
candidate,
was_first,
&mut conflicts,
)
.await
{
Ok(answered) => {
info!(number = %candidate, "claimed a browsable device number");
return Ok((candidate.number(), answered));
}
Err(holder) => {
warn!(number = %candidate, %holder, "number is taken; backing off");
}
}
}
Err(discovery.no_browsable_number())
}
async fn claim_one(
socket: &UdpSocket,
to: SocketAddr,
config: &VirtualCdjConfig,
interface: &crate::Interface,
candidate: BrowsableDeviceNumber,
was_first: bool,
conflicts: &mut broadcast::Receiver<crate::discovery::Announcement>,
) -> std::result::Result<bool, Ipv4Addr> {
let final_stage = if was_first { 3 } else { 1 };
let mut stages: Vec<Body> = Vec::new();
for iteration in 1..=3 {
stages.push(Body::Hello {
payload: config.kind.role(),
});
let _ = iteration;
}
for iteration in 1..=3 {
stages.push(Body::ClaimMac {
iteration,
flags: config.kind.role(),
mac: interface.mac,
});
}
for iteration in 1..=3 {
stages.push(Body::ClaimIp {
ip: interface.ip,
mac: interface.mac,
device_number: candidate.get(),
iteration,
role: config.kind.role(),
assignment_mode: djl::AssignmentMode::MANUAL,
});
}
for iteration in 1..=final_stage {
stages.push(Body::ClaimNumber {
device_number: candidate.get(),
iteration,
});
}
for body in stages {
let stage_3 = matches!(body, Body::ClaimNumber { .. });
let packet = djl::Packet::new(config.name, config.kind, body);
if let Err(error) = socket.send_to(&packet.encode(), to).await {
warn!(%error, "claim packet failed");
}
let deadline = tokio::time::sleep(djl::DISCOVERY_INTERVAL);
tokio::pin!(deadline);
loop {
tokio::select! {
() = &mut deadline => break,
received = conflicts.recv() => {
let Ok(announcement) = received else { break };
if let Some(holder) = contested(&announcement, candidate, interface) {
return Err(holder);
}
if stage_3 && answers_our_claim(&announcement) {
return Ok(true);
}
}
}
}
}
Ok(false)
}
fn answers_our_claim(announcement: &crate::discovery::Announcement) -> bool {
matches!(announcement.packet.body, Body::NumberInUse { .. })
}
fn steps_aside(
announcement: &crate::discovery::Announcement,
ours: prolink_proto::MacAddress,
) -> bool {
matches!(
announcement.packet.body,
Body::KeepAlive {
was_first_on_network: FIRST_ON_NETWORK,
mac,
..
} if mac != ours
)
}
fn contested(
announcement: &crate::discovery::Announcement,
candidate: BrowsableDeviceNumber,
interface: &crate::Interface,
) -> Option<Ipv4Addr> {
match announcement.packet.body {
Body::NumberConflict { device_number, ip } if device_number == candidate.get() => {
Some(if ip.is_unspecified() {
announcement.from
} else {
ip
})
}
Body::ClaimIp {
device_number, ip, ..
} if device_number == candidate.get() && outranks(ip, interface) => Some(ip),
Body::ClaimNumber { device_number, .. }
if device_number == candidate.get() && outranks(announcement.from, interface) =>
{
Some(announcement.from)
}
_ => None,
}
}
fn outranks(ip: Ipv4Addr, interface: &crate::Interface) -> bool {
!ip.is_unspecified() && ip < interface.ip
}
#[derive(Debug)]
struct PeerAddresses {
devices: Arc<Mutex<Vec<Ipv4Addr>>>,
task: JoinHandle<()>,
}
impl PeerAddresses {
fn new(discovery: &Discovery) -> Self {
let devices = Arc::new(Mutex::new(
discovery
.online()
.into_iter()
.map(|device| device.ip)
.collect::<Vec<_>>(),
));
let mut events = discovery.subscribe();
let shared = Arc::clone(&devices);
let task = tokio::spawn(async move {
loop {
let Ok(event) = events.recv().await else {
return;
};
let ip = event.device().ip;
let add = !matches!(
event,
crate::device::DeviceEvent::Forgotten(_)
| crate::device::DeviceEvent::WentOffline(_)
);
let mut devices = match shared.lock() {
Ok(devices) => devices,
Err(poisoned) => poisoned.into_inner(),
};
devices.retain(|known| *known != ip);
if add {
devices.push(ip);
}
}
});
Self { devices, task }
}
fn get(&self) -> Vec<Ipv4Addr> {
match self.devices.lock() {
Ok(devices) => devices.clone(),
Err(poisoned) => poisoned.into_inner().clone(),
}
}
fn len(&self) -> usize {
match self.devices.lock() {
Ok(devices) => devices.len(),
Err(poisoned) => poisoned.into_inner().len(),
}
}
}
impl Drop for PeerAddresses {
fn drop(&mut self) {
self.task.abort();
}
}
#[cfg(test)]
mod tests {
#[test]
fn a_capture_of_a_deck_loading_from_us_fills_the_registry() {
let Some(corpus) = prolink_capture::Corpus::locate() else {
return;
};
let path = corpus.root().join("S27-sort-by-and-key/run.pcap");
let Ok(capture) = prolink_capture::Capture::open(&path) else {
return;
};
let loaded = LoadedTracks::default();
let mut seen = 0usize;
for packet in capture.udp_to(STATUS_PORT).flatten() {
let Ok(status::Packet::CdjStatus(peer)) = status::decode(&packet.payload) else {
continue;
};
let Some(source) = peer.source_player() else {
continue;
};
observe_loaded(&loaded, source, &peer);
seen += 1;
}
assert!(
seen > 100,
"the corpus should hold plenty of status packets"
);
assert!(
!loaded.by_device.lock().expect("not poisoned").is_empty(),
"no deck's loaded track was recorded from {seen} status packets"
);
}
#[test]
fn a_track_loaded_from_another_player_is_not_ours_to_mark() {
let loaded = LoadedTracks::default();
let ours = DeviceNumber::new(4).expect("4 is a device number");
let theirs = DeviceNumber::new(1).expect("1 is a device number");
let mut raw = CdjStatus::builder()
.device_number(DeviceNumber::new(2).expect("2 is a device number"))
.name(DeviceName::default())
.build()
.into_bytes();
raw[0x28] = theirs.get();
raw[0x29] = Slot::USB.0;
raw[0x2c..0x30].copy_from_slice(&99u32.to_be_bytes());
let peer = CdjStatus::parse(&raw).expect("a status packet");
observe_loaded(&loaded, ours, &peer);
assert_eq!(loaded.track_on(2, Slot::USB), None);
raw[0x28] = ours.get();
let peer = CdjStatus::parse(&raw).expect("a status packet");
observe_loaded(&loaded, ours, &peer);
assert_eq!(loaded.track_on(2, Slot::USB), Some(99));
}
use super::*;
use prolink_proto::status::MediaState;
fn interface() -> crate::Interface {
crate::Interface {
name: "test0".to_owned(),
index: 1,
ip: Ipv4Addr::new(169, 254, 99, 100),
netmask: Ipv4Addr::new(255, 255, 0, 0),
mac: prolink_proto::MacAddress([0xa0, 0xce, 0xc8, 0xe2, 0x26, 0xde]),
}
}
fn announcement(body: Body, from: [u8; 4]) -> crate::discovery::Announcement {
crate::discovery::Announcement {
packet: djl::Packet::new(DeviceName::default(), DeviceKind::CDJ, body),
from: Ipv4Addr::from(from),
}
}
fn browsable(number: u8) -> BrowsableDeviceNumber {
BrowsableDeviceNumber::new(number).expect("a browsable device number")
}
#[test]
fn a_rival_claiming_our_number_at_once_is_settled_by_address() {
let ours = interface(); let claim_ip = |ip: [u8; 4], number: u8| {
announcement(
Body::ClaimIp {
ip: Ipv4Addr::from(ip),
mac: prolink_proto::MacAddress([2, 0, 0, 0, 0, 1]),
device_number: number,
iteration: 1,
role: DeviceKind::CDJ.role(),
assignment_mode: djl::AssignmentMode::MANUAL,
},
ip,
)
};
let lower = [169, 254, 3, 7];
let higher = [169, 254, 200, 1];
assert_eq!(
contested(&claim_ip(lower, 4), browsable(4), &ours),
Some(Ipv4Addr::from(lower)),
"a lower address claiming our candidate keeps it"
);
assert_eq!(
contested(&claim_ip(higher, 4), browsable(4), &ours),
None,
"a higher one backs off itself, by the same rule"
);
assert_eq!(
contested(&claim_ip(lower, 3), browsable(4), &ours),
None,
"another number is no contest"
);
assert_eq!(
contested(&claim_ip(ours.ip.octets(), 4), browsable(4), &ours),
None,
"our own claim, heard back, is not a rival"
);
let claim_number = |from: [u8; 4]| {
announcement(
Body::ClaimNumber {
device_number: 4,
iteration: 1,
},
from,
)
};
assert_eq!(
contested(&claim_number(lower), browsable(4), &ours),
Some(Ipv4Addr::from(lower)),
"the last stage carries no address of its own: the sender's decides"
);
assert_eq!(contested(&claim_number(higher), browsable(4), &ours), None);
assert_eq!(
contested(&claim_number(ours.ip.octets()), browsable(4), &ours),
None
);
assert_eq!(
contested(&claim_number([0, 0, 0, 0]), browsable(4), &ours),
None,
"nor does a sender with no address"
);
}
#[test]
fn real_hardware_takes_a_number_from_a_claim_only_by_claiming_it() {
let Some(corpus) = prolink_capture::Corpus::locate() else {
return;
};
let lowest = crate::Interface {
ip: Ipv4Addr::new(169, 254, 0, 1),
..interface()
};
let highest = crate::Interface {
ip: Ipv4Addr::new(169, 254, 255, 254),
..interface()
};
let (mut packets, mut rival_claims) = (0usize, 0usize);
for path in corpus.captures() {
let Ok(capture) = prolink_capture::Capture::open(&path) else {
continue;
};
for packet in capture.udp_to(DISCOVERY_PORT).flatten() {
let Ok(decoded) = djl::Packet::decode(&packet.payload) else {
continue;
};
packets += 1;
let heard = crate::discovery::Announcement {
packet: decoded,
from: *packet.source.ip(),
};
for number in 1..=4 {
let candidate = browsable(number);
let (expected_low, expected_high) = match heard.packet.body {
Body::NumberConflict { device_number, .. } if device_number == number => {
let holder = contested(&heard, candidate, &lowest);
assert!(holder.is_some(), "a defence must always win");
(holder, holder)
}
Body::ClaimIp {
device_number, ip, ..
} if device_number == number && !ip.is_unspecified() => {
rival_claims += 1;
(None, Some(ip))
}
Body::ClaimNumber { device_number, .. } if device_number == number => {
rival_claims += 1;
(None, Some(heard.from))
}
_ => (None, None),
};
assert_eq!(
contested(&heard, candidate, &lowest),
expected_low,
"{} frame {}: {:?} claiming {number} from below everyone",
path.display(),
packet.index,
heard.packet.body
);
assert_eq!(
contested(&heard, candidate, &highest),
expected_high,
"{} frame {}: {:?} claiming {number} from above everyone",
path.display(),
packet.index,
heard.packet.body
);
}
}
}
assert!(
packets > 1000,
"only {packets} discovery packets in the corpus"
);
assert!(
rival_claims > 0,
"the corpus holds real claims, and each one is checked above"
);
}
fn keep_alive_from(mac: [u8; 6], was_first_on_network: u8) -> crate::discovery::Announcement {
announcement(
Body::KeepAlive {
device_number: 1,
was_first_on_network,
mac: prolink_proto::MacAddress(mac),
ip: Ipv4Addr::new(169, 254, 103, 172),
peer_count: 2,
pad_31: [0; 3],
flags: DeviceKind::CDJ.role(),
trailing: 0,
},
[169, 254, 103, 172],
)
}
#[test]
fn another_device_saying_it_was_first_makes_us_step_aside() {
let ours = interface().mac;
assert!(
steps_aside(
&keep_alive_from([0x74, 0x5e, 0x1c, 0x56, 0x67, 0xac], 0x02),
ours
),
"a player saying 0x02 holds the role, and we leave it to it"
);
assert!(
!steps_aside(
&keep_alive_from([0x74, 0x5e, 0x1c, 0x56, 0x67, 0xac], 0x01),
ours
),
"a player saying 0x01 holds nothing we have to give up"
);
assert!(
!steps_aside(&keep_alive_from(ours.0, 0x02), ours),
"our own keep-alive comes back to us, and is ours by its MAC"
);
let claim = announcement(
Body::ClaimNumber {
device_number: 2,
iteration: 1,
},
[169, 254, 202, 84],
);
assert!(
!steps_aside(&claim, ours),
"a claim says nothing of the role"
);
}
#[test]
fn only_a_0x05_answers_our_claim() {
let answer = announcement(
Body::NumberInUse {
device_number: 2,
iteration: 1,
},
[169, 254, 202, 84],
);
assert!(answers_our_claim(&answer));
let claim = announcement(
Body::ClaimNumber {
device_number: 2,
iteration: 1,
},
[169, 254, 202, 84],
);
assert!(
!answers_our_claim(&claim),
"a rival's claim is not an answer"
);
assert!(!answers_our_claim(&keep_alive_from(
[2, 0, 0, 0, 0, 1],
0x02
)));
}
#[test]
fn real_hardware_asks_us_to_step_aside_only_by_saying_it_was_first() {
let Some(corpus) = prolink_capture::Corpus::locate() else {
return;
};
let ours = prolink_proto::MacAddress([0x02, 0xff, 0xff, 0xff, 0xff, 0xfe]);
let (mut said_first, mut answers, mut others) = (0usize, 0usize, 0usize);
for path in corpus.captures() {
let Ok(capture) = prolink_capture::Capture::open(&path) else {
continue;
};
for packet in capture.udp_to(DISCOVERY_PORT).flatten() {
let Ok(decoded) = djl::Packet::decode(&packet.payload) else {
continue;
};
let heard = crate::discovery::Announcement {
packet: decoded,
from: *packet.source.ip(),
};
let first = matches!(
heard.packet.body,
Body::KeepAlive {
was_first_on_network: FIRST_ON_NETWORK,
..
}
);
let answer = matches!(heard.packet.body, Body::NumberInUse { .. });
assert_eq!(
steps_aside(&heard, ours),
first,
"{} frame {}: {:?}",
path.display(),
packet.index,
heard.packet.body
);
assert_eq!(answers_our_claim(&heard), answer);
match (first, answer) {
(true, _) => said_first += 1,
(_, true) => answers += 1,
_ => others += 1,
}
}
}
assert!(
said_first > 1000,
"only {said_first} keep-alives saying 0x02"
);
assert!(others > 1000, "only {others} other discovery packets");
assert_eq!(answers, 2, "the corpus holds two 0x05s, S13's and S26's");
}
async fn claim_against(
answer: Option<crate::discovery::Announcement>,
) -> (std::result::Result<bool, Ipv4Addr>, Vec<Body>) {
let player_socket = UdpSocket::bind("127.0.0.1:0").await.expect("a socket");
let to = player_socket.local_addr().expect("its address");
let socket = UdpSocket::bind("127.0.0.1:0").await.expect("a socket");
let (tell, mut heard) = broadcast::channel(16);
let player = tokio::spawn(async move {
let mut answer = answer;
let mut sent = Vec::new();
let mut buffer = [0u8; 128];
while let Ok(Ok(len)) =
tokio::time::timeout(Duration::from_millis(500), player_socket.recv(&mut buffer))
.await
{
let packet = djl::Packet::decode(&buffer[..len]).expect("our own packet");
if matches!(packet.body, Body::ClaimNumber { .. })
&& let Some(answer) = answer.take()
{
let _ = tell.send(answer);
}
sent.push(packet.body);
}
sent
});
let result = claim_one(
&socket,
to,
&VirtualCdjConfig::default(),
&interface(),
browsable(4),
true,
&mut heard,
)
.await;
(result, player.await.expect("the stand-in player"))
}
#[tokio::test]
async fn a_0x05_ends_our_burst_and_we_do_not_take_the_role() {
const S13_ANSWER: &[u8] = &[
0x51, 0x73, 0x70, 0x74, 0x31, 0x57, 0x6d, 0x4a, 0x4f, 0x4c, 0x05, 0x00, 0x43, 0x44,
0x4a, 0x2d, 0x32, 0x30, 0x30, 0x30, 0x6e, 0x65, 0x78, 0x75, 0x73, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x26, 0x02, 0x01,
];
let answer = crate::discovery::Announcement {
packet: djl::Packet::decode(S13_ANSWER).expect("S13's 0x05 decodes"),
from: Ipv4Addr::new(169, 254, 202, 84),
};
let claims = |sent: &[Body]| {
sent.iter()
.filter(|body| matches!(body, Body::ClaimNumber { .. }))
.count()
};
let ((answered, sent_answered), (unanswered, sent_unanswered)) =
tokio::join!(claim_against(Some(answer)), claim_against(None));
assert_eq!(
answered,
Ok(true),
"the number is ours, and we were answered"
);
assert_eq!(
(sent_answered.len(), claims(&sent_answered)),
(10, 1),
"the burst ends at the answer: S13's player 1 sent one claim"
);
assert_eq!(unanswered, Ok(false));
assert_eq!((sent_unanswered.len(), claims(&sent_unanswered)), (12, 3));
}
fn published(tempo_master: bool, yielding_to: Option<u8>) -> Published {
Published {
tempo_master,
yielding_to: yielding_to.and_then(DeviceNumber::new),
synced: false,
playing: true,
play_state: crate::monitor::PlayState::PLAYING.0,
loaded: None,
usb: MediaState::EMPTY,
sd: MediaState::EMPTY,
}
}
#[test]
fn status_goes_out_every_200_ms_unchanged_and_at_once_on_a_change() {
let sent = Instant::now();
let master = published(true, None);
let ms = |n: u64| sent + Duration::from_millis(n);
assert!(status_due(None, sent, master), "the first one goes at once");
let last = Some((sent, master));
assert!(!status_due(last, ms(100), master), "nothing new: wait");
assert!(!status_due(last, ms(199), master));
assert!(status_due(last, ms(200), master), "the 200 ms cadence");
let handing_over = published(true, Some(2));
assert!(status_due(last, ms(62), handing_over));
assert!(
!status_due(last, ms(61), handing_over),
"but never sooner than 62 ms after the last packet: S28's floor"
);
}
#[test]
fn what_a_peer_acts_on_at_once_is_what_triggers_a_packet() {
let master = published(true, None);
assert_ne!(master, published(true, Some(2)), "a successor named");
assert_ne!(master, published(false, None), "master given up");
assert_ne!(
master,
Published {
playing: false,
play_state: crate::monitor::PlayState::PAUSED.0,
..master
},
"a stop"
);
assert_ne!(
master,
Published {
synced: true,
..master
},
"SYNC lit"
);
assert_ne!(
master,
Published {
usb: MediaState::UNMOUNTING,
..master
},
"an eject's first step"
);
}
fn bare_cdj() -> VirtualCdj {
VirtualCdj {
config: VirtualCdjConfig::default(),
interface: interface(),
number: Arc::new(AtomicU8::new(3)),
phase: watch::channel(Phase::Announcing).0,
media: Arc::new(NoMedia),
loaded: Arc::new(LoadedTracks::default()),
peers: Arc::new(PeerMedia::default()),
status_socket: None,
status_tap: None,
status_counter: Arc::new(AtomicU32::new(0)),
playback: Arc::new(PlaybackCell::default()),
playing_track: Arc::new(Mutex::new(None)),
tempo_master: Arc::new(AtomicBool::new(false)),
yielding_to: Arc::new(AtomicU8::new(0)),
synced: Arc::new(AtomicBool::new(false)),
first_on_network: Arc::new(AtomicBool::new(false)),
tasks: Vec::new(),
}
}
#[test]
fn a_master_offers_its_mastership_to_one_deck_at_a_time() {
let cdj = bare_cdj();
let two = DeviceNumber::new(2).expect("2 is a device number");
let four = DeviceNumber::new(4).expect("4 is a device number");
assert!(!cdj.offer_tempo_master(two), "not master: nothing to offer");
cdj.set_tempo_master(true);
assert!(cdj.offer_tempo_master(two));
assert_eq!(cdj.yielding_to(), Some(two));
assert!(
!cdj.offer_tempo_master(four),
"an offer in flight is not written over"
);
assert_eq!(cdj.yielding_to(), Some(two), "0x9f still names the first");
cdj.withdraw_offer();
assert!(cdj.offer_tempo_master(four));
assert_eq!(cdj.yielding_to(), Some(four));
cdj.finish_yield();
assert!(!cdj.offer_tempo_master(two));
assert_eq!(cdj.yielding_to(), None);
}
#[test]
fn a_holder_defending_our_candidate_still_takes_it() {
let ours = interface();
let defended = announcement(
Body::NumberConflict {
device_number: 4,
ip: Ipv4Addr::new(169, 254, 250, 250),
},
[169, 254, 250, 250],
);
assert_eq!(
contested(&defended, browsable(4), &ours),
Some(Ipv4Addr::new(169, 254, 250, 250)),
"a defence wins whatever the address"
);
}
#[test]
fn the_default_numbering_cannot_disturb_a_live_rig() {
let Numbering::Observer(number) = Numbering::default() else {
panic!("the default must not claim");
};
assert_eq!(number, OBSERVER_NUMBER);
assert!(
!number.is_player(),
"outside 1-6, so it cannot collide with hardware"
);
assert!(
number.browsable().is_none(),
"and cannot be browsed, by construction"
);
}
#[test]
fn our_keep_alive_matches_a_real_deck_byte_for_byte() {
const REAL: &[u8] = &[
0x51, 0x73, 0x70, 0x74, 0x31, 0x57, 0x6d, 0x4a, 0x4f, 0x4c, 0x06, 0x00, 0x43, 0x44,
0x4a, 0x2d, 0x32, 0x30, 0x30, 0x30, 0x6e, 0x65, 0x78, 0x75, 0x73, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x36, 0x05, 0x02, 0xa0, 0xce, 0xc8, 0xe2,
0x26, 0xde, 0xa9, 0xfe, 0x63, 0x64, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
];
let config = VirtualCdjConfig {
numbering: Numbering::Observer(DeviceNumber::new(5).unwrap()),
..VirtualCdjConfig::default()
};
let number = AtomicU8::new(5);
let packet = keep_alive_packet(&config, &interface(), &number, 0, true);
assert_eq!(packet.encode(), REAL);
}
#[test]
fn a_status_packet_reports_only_the_slots_we_serve() {
#[derive(Debug)]
struct UsbOnly;
impl MediaSource for UsbOnly {
fn occupied_slots(&self) -> std::collections::BTreeSet<Slot> {
[Slot::USB].into_iter().collect()
}
fn describe(&self, slot: Slot) -> Option<MediaDescription> {
(slot == Slot::USB).then(MediaDescription::default)
}
}
let number = AtomicU8::new(3);
let counter = AtomicU32::new(0);
let packet = status_packet(
&VirtualCdjConfig::default(),
&number,
&UsbOnly,
&counter,
1,
Transport {
playback: &Playback::default(),
loaded: None,
tempo_master: false,
yielding_to: None,
synced: false,
},
);
assert_eq!(packet.usb_state(), MediaState::LOADED);
assert_eq!(
packet.sd_state(),
MediaState::EMPTY,
"a slot we do not serve is empty"
);
assert!(packet.link_available());
assert_eq!(
packet.bpm_centi(),
None,
"a server with nothing playing states no tempo"
);
assert_eq!(packet.beat_in_bar(), None);
}
fn playing_track() -> status::LoadedTrack {
status::LoadedTrack {
source_player: DeviceNumber::new(2).expect("device 2"),
slot: Slot::USB,
id: 42,
track_type: prolink_proto::dbserver::TrackType::REKORDBOX,
}
}
fn playing() -> Playback {
Playback {
bpm_centi: Some(14_500),
pitch: prolink_proto::beat::Pitch::UNITY,
playing: true,
beat: Some(BeatPosition {
number: 6,
fraction: 0.5,
}),
scratching: false,
}
}
#[test]
fn what_we_are_playing_reaches_the_status_packet() {
let number = AtomicU8::new(2);
let counter = AtomicU32::new(0);
let packet = status_packet(
&VirtualCdjConfig::default(),
&number,
&NoMedia,
&counter,
1,
Transport {
playback: &playing(),
loaded: Some(playing_track()),
tempo_master: true,
yielding_to: None,
synced: false,
},
);
assert_eq!(packet.bpm_centi(), Some(14_500));
assert_eq!(packet.beat_number(), Some(6));
assert_eq!(packet.beat_in_bar(), prolink_proto::beat::BeatInBar::new(2));
assert_eq!(packet.is_tempo_master(), Some(true));
assert_eq!(packet.track_id(), 42);
assert_eq!(packet.source_slot(), Slot::USB);
assert_eq!(packet.track_type(), 1);
assert_eq!(
packet.play_state(),
Some(crate::monitor::PlayState::PLAYING.0)
);
}
#[test]
fn a_handover_names_its_successor_and_keeps_the_claim() {
let number = AtomicU8::new(2);
let counter = AtomicU32::new(0);
let successor = DeviceNumber::new(3).expect("a device number");
let packet = status_packet(
&VirtualCdjConfig::default(),
&number,
&NoMedia,
&counter,
1,
Transport {
playback: &playing(),
loaded: Some(playing_track()),
tempo_master: true,
yielding_to: Some(successor),
synced: false,
},
);
assert_eq!(packet.is_tempo_master(), Some(true));
assert_eq!(packet.yielding_to(), Some(successor));
}
#[test]
fn no_handover_leaves_the_successor_byte_empty() {
let number = AtomicU8::new(2);
let counter = AtomicU32::new(0);
let packet = status_packet(
&VirtualCdjConfig::default(),
&number,
&NoMedia,
&counter,
1,
Transport {
playback: &playing(),
loaded: Some(playing_track()),
tempo_master: true,
yielding_to: None,
synced: false,
},
);
assert_eq!(packet.yielding_to(), None);
}
#[test]
fn a_paused_deck_still_states_its_tempo() {
let number = AtomicU8::new(2);
let counter = AtomicU32::new(0);
let packet = status_packet(
&VirtualCdjConfig::default(),
&number,
&NoMedia,
&counter,
0,
Transport {
playback: &Playback {
playing: false,
..playing()
},
loaded: Some(playing_track()),
tempo_master: false,
yielding_to: None,
synced: false,
},
);
assert_eq!(packet.bpm_centi(), Some(14_500));
assert_eq!(
packet.play_state(),
Some(crate::monitor::PlayState::PAUSED.0)
);
assert_eq!(
packet.flags().map(status::StatusFlags::is_playing),
Some(false)
);
}
fn at(number: u32, fraction: f64) -> Playback {
Playback {
beat: Some(BeatPosition { number, fraction }),
..playing()
}
}
#[test]
fn a_beat_goes_out_once_on_its_downbeat() {
let mut emitted = None;
assert_eq!(beat_to_emit(&at(6, 0.5), &mut emitted), None);
assert_eq!(beat_to_emit(&at(6, 0.9), &mut emitted), None);
let next = beat_to_emit(&at(7, 0.005), &mut emitted).expect("beat 7");
assert_eq!(next.number, 7);
assert!(next.fraction.abs() < f64::EPSILON);
assert_eq!(beat_to_emit(&at(7, 0.02), &mut emitted), None);
}
#[test]
fn a_crossing_noticed_late_is_skipped_not_sent_late() {
let mut emitted = None;
beat_to_emit(&at(6, 0.9), &mut emitted);
assert_eq!(beat_to_emit(&at(7, 0.3), &mut emitted), None);
assert_eq!(
beat_to_emit(&at(8, 0.0), &mut emitted).map(|p| p.number),
Some(8)
);
}
#[test]
fn a_jump_forwards_sends_no_burst() {
let mut emitted = None;
beat_to_emit(&at(6, 0.9), &mut emitted);
assert_eq!(beat_to_emit(&at(70, 0.4), &mut emitted), None);
assert_eq!(beat_to_emit(&at(70, 0.6), &mut emitted), None);
assert_eq!(
beat_to_emit(&at(71, 0.0), &mut emitted).map(|p| p.number),
Some(71)
);
}
#[test]
fn a_jump_backwards_resumes_at_the_next_beat() {
let mut emitted = None;
beat_to_emit(&at(40, 0.5), &mut emitted);
assert_eq!(beat_to_emit(&at(2, 0.5), &mut emitted), None);
assert_eq!(
beat_to_emit(&at(3, 0.004), &mut emitted).map(|p| p.number),
Some(3)
);
}
#[test]
fn a_jump_that_lands_on_a_downbeat_sends_it() {
let mut emitted = None;
beat_to_emit(&at(40, 0.5), &mut emitted);
assert_eq!(
beat_to_emit(&at(17, 0.0), &mut emitted).map(|p| p.number),
Some(17)
);
}
#[test]
fn a_scratched_platter_sends_no_beats() {
let mut emitted = None;
beat_to_emit(&at(6, 0.9), &mut emitted);
let scratched = Playback {
scratching: true,
..at(7, 0.0)
};
assert_eq!(beat_to_emit(&scratched, &mut emitted), None);
assert_eq!(beat_to_emit(&at(7, 0.5), &mut emitted), None);
assert_eq!(
beat_to_emit(&at(8, 0.0), &mut emitted).map(|p| p.number),
Some(8)
);
}
#[test]
fn nothing_playing_emits_nothing_and_forgets_where_it_was() {
let mut emitted = None;
beat_to_emit(&at(6, 0.5), &mut emitted);
let stopped = Playback {
playing: false,
..at(6, 0.5)
};
assert_eq!(beat_to_emit(&stopped, &mut emitted), None);
assert_eq!(emitted, None);
assert_eq!(
beat_to_emit(&at(6, 0.0), &mut emitted).map(|p| p.number),
Some(6)
);
}
#[test]
fn a_slot_being_ejected_publishes_the_state_a_consumer_acts_on() {
#[derive(Debug)]
struct Ejecting;
impl MediaSource for Ejecting {
fn occupied_slots(&self) -> std::collections::BTreeSet<Slot> {
std::collections::BTreeSet::new()
}
fn describe(&self, _slot: Slot) -> Option<MediaDescription> {
None
}
fn slot_state(&self, slot: Slot) -> MediaState {
if slot == Slot::USB {
MediaState::UNMOUNTING_ALT
} else {
MediaState::EMPTY
}
}
}
let number = AtomicU8::new(3);
let counter = AtomicU32::new(0);
let packet = status_packet(
&VirtualCdjConfig::default(),
&number,
&Ejecting,
&counter,
1,
Transport {
playback: &Playback::default(),
loaded: None,
tempo_master: false,
yielding_to: None,
synced: false,
},
);
assert_eq!(packet.usb_state(), MediaState::UNMOUNTING_ALT);
assert_eq!(packet.sd_state(), MediaState::EMPTY);
}
fn peer_status(device: u8, usb: MediaState, sd: MediaState) -> CdjStatus {
let number = DeviceNumber::new(device).expect("a real device number");
CdjStatus::builder()
.device_number(number)
.name(DeviceName::default())
.slot_state(Slot::USB, usb)
.slot_state(Slot::SD, sd)
.build()
}
#[test]
fn a_peers_status_packet_says_which_of_its_slots_hold_media() {
let peers = PeerMedia::default();
observe_peer_slots(
&peers,
&peer_status(2, MediaState::LOADED, MediaState::EMPTY),
);
let device = DeviceNumber::new(2).unwrap();
let usb = peers.get(device, Slot::USB).expect("the USB is known");
assert!(usb.has_media());
assert!(
!peers
.get(device, Slot::SD)
.expect("the SD is known too")
.has_media(),
"an empty slot is known to be empty, which is not the same as unknown"
);
assert_eq!(peers.occupied().len(), 1);
assert_eq!(
usb.track_count(),
None,
"nothing has described it yet, and occupancy does not imply a count"
);
}
#[test]
fn a_media_response_names_the_medium_and_counts_it() {
let peers = PeerMedia::default();
let device = DeviceNumber::new(2).unwrap();
let raw = status::MediaResponse::builder()
.device_number(device)
.slot(Slot::USB)
.name(DeviceName::default())
.volume_name("SAM2")
.counts(692, 35)
.build()
.into_bytes();
let response = status::MediaResponse::parse(&raw).expect("our own encoding parses");
observe_peer_media(&peers, &response);
let usb = peers.get(device, Slot::USB).expect("the USB is described");
assert_eq!(usb.volume_name(), "SAM2");
assert_eq!(usb.track_count(), Some(692));
assert_eq!(usb.playlist_count(), Some(35));
assert!(
!usb.has_media(),
"a description is not evidence of a medium: a deck answers for an empty slot too (F51)"
);
}
#[test]
fn the_two_halves_of_a_slot_arrive_separately_and_do_not_overwrite_each_other() {
let peers = PeerMedia::default();
let device = DeviceNumber::new(2).unwrap();
let raw = status::MediaResponse::builder()
.device_number(device)
.slot(Slot::USB)
.name(DeviceName::default())
.volume_name("SAM2")
.counts(692, 35)
.build()
.into_bytes();
observe_peer_media(
&peers,
&status::MediaResponse::parse(&raw).expect("it parses"),
);
observe_peer_slots(
&peers,
&peer_status(2, MediaState::LOADED, MediaState::EMPTY),
);
let usb = peers.get(device, Slot::USB).expect("both halves landed");
assert!(usb.has_media(), "the status packet supplied the occupancy");
assert_eq!(usb.track_count(), Some(692), "and the response the counts");
observe_peer_slots(
&peers,
&peer_status(2, MediaState::UNMOUNTING, MediaState::EMPTY),
);
let usb = peers.get(device, Slot::USB).expect("still there");
assert_eq!(usb.state, MediaState::UNMOUNTING);
assert_eq!(usb.volume_name(), "SAM2");
}
#[test]
fn a_pulled_mediums_name_goes_with_it() {
let peers = PeerMedia::default();
let deck = DeviceNumber::new(1).expect("1 is a device number");
peers.note_state(deck, Slot::USB, MediaState::LOADED);
peers.note_description(
deck,
Slot::USB,
&MediaDescription {
volume_name: "SAM1".to_owned(),
created: "2026-01-04".to_owned(),
track_count: 141,
playlist_count: 4,
total_bytes: None,
free_bytes: None,
plain: false,
},
);
assert_eq!(
peers.get(deck, Slot::USB).expect("a slot").volume_name(),
"SAM1"
);
peers.note_state(deck, Slot::USB, MediaState::UNMOUNTING);
peers.note_state(deck, Slot::USB, MediaState::UNMOUNTING_ALT);
assert_eq!(
peers.get(deck, Slot::USB).expect("a slot").volume_name(),
"SAM1"
);
peers.note_state(deck, Slot::USB, MediaState::EMPTY);
let pulled = peers.get(deck, Slot::USB).expect("a slot");
assert!(
pulled.description.is_none(),
"the medium's name went with it"
);
assert_eq!(pulled.volume_name(), "");
peers.note_state(deck, Slot::USB, MediaState::LOADED);
assert!(
peers
.get(deck, Slot::USB)
.expect("a slot")
.description
.is_none()
);
}
#[test]
fn peers_are_listed_by_device_and_slot() {
let peers = PeerMedia::default();
observe_peer_slots(
&peers,
&peer_status(3, MediaState::LOADED, MediaState::LOADED),
);
observe_peer_slots(
&peers,
&peer_status(1, MediaState::LOADED, MediaState::EMPTY),
);
let listed: Vec<_> = peers
.all()
.into_iter()
.map(|entry| (entry.device.get(), entry.slot))
.collect();
assert_eq!(
listed,
vec![(1, Slot::SD), (1, Slot::USB), (3, Slot::SD), (3, Slot::USB)],
"device order first, so a listing reads like the rig looks"
);
assert_eq!(peers.of(DeviceNumber::new(3).unwrap()).len(), 2);
}
#[test]
fn a_media_query_for_a_slot_we_do_not_serve_gets_no_answer() {
let ours = DeviceNumber::new(3).unwrap();
let query = status::MediaQuery {
requester: DeviceNumber::new(2).unwrap(),
requester_ip: Ipv4Addr::new(169, 254, 1, 2),
target: ours,
slot: Slot::SD,
};
assert!(answer_media_query(query, ours, DeviceName::default(), &NoMedia).is_none());
}
#[test]
fn a_media_query_addressed_elsewhere_gets_no_answer() {
let ours = DeviceNumber::new(3).unwrap();
let query = status::MediaQuery {
requester: DeviceNumber::new(2).unwrap(),
requester_ip: Ipv4Addr::new(169, 254, 1, 2),
target: DeviceNumber::new(4).unwrap(),
slot: Slot::USB,
};
assert!(answer_media_query(query, ours, DeviceName::default(), &NoMedia).is_none());
}
}