use std::net::Ipv4Addr;
use std::sync::atomic::{AtomicU8, Ordering};
use std::sync::{Arc, RwLock};
use std::time::Duration;
use prolink_proto::status::MediaState;
use prolink_proto::{BrowsableDeviceNumber, DeviceKind, DeviceName, Slot};
use tracing::{info, warn};
use crate::discovery::Discovery;
use crate::interface::Interface;
use crate::media::{MediaDescription, MediaSource};
use crate::serve::dbserver::{DbServer, DbServerConfig};
use crate::serve::medium::Medium;
use crate::serve::nfs::{NfsConfig, NfsServer, Ports};
use crate::serve::preserve::Preserve;
use crate::serve::vfs::{Preserved, Vfs};
use crate::virtual_cdj::{Numbering, VirtualCdj, VirtualCdjConfig};
use crate::{Error, Result};
#[derive(Clone, Debug)]
pub struct VirtualPlayerConfig {
pub interface: Interface,
pub preferred_number: Option<BrowsableDeviceNumber>,
pub name: DeviceName,
pub kind: DeviceKind,
pub generation: u8,
pub portmap_port: u16,
}
impl VirtualPlayerConfig {
pub fn new(interface: Interface) -> Self {
Self {
interface,
preferred_number: None,
name: DeviceName::default(),
kind: DeviceKind::CDJ,
generation: 0x00,
portmap_port: prolink_proto::rpc::portmap::PORT,
}
}
}
#[derive(Debug, Default)]
pub struct MediaSet {
slots: RwLock<Vec<Entry>>,
}
#[derive(Debug)]
struct Entry {
medium: Arc<Medium>,
state: AtomicU8,
}
impl MediaSet {
pub fn new(media: impl IntoIterator<Item = Arc<Medium>>) -> Self {
let set = Self::default();
for medium in media {
set.insert(medium);
}
set
}
pub fn insert(&self, medium: Arc<Medium>) {
let slot = medium.slot().slot();
self.write(|slots| {
slots.retain(|entry| entry.medium.slot().slot() != slot);
slots.push(Entry {
medium,
state: AtomicU8::new(MediaState::LOADED.0),
});
});
}
pub fn remove(&self, slot: Slot) -> Option<Arc<Medium>> {
self.write(|slots| {
let index = slots
.iter()
.position(|entry| entry.medium.slot().slot() == slot)?;
Some(slots.remove(index).medium)
})
}
pub fn get(&self, slot: Slot) -> Option<Arc<Medium>> {
self.read(|slots| {
slots
.iter()
.find(|entry| entry.medium.slot().slot() == slot)
.map(|entry| Arc::clone(&entry.medium))
})
}
pub fn all(&self) -> Vec<Arc<Medium>> {
self.read(|slots| {
slots
.iter()
.map(|entry| Arc::clone(&entry.medium))
.collect()
})
}
pub fn len(&self) -> usize {
self.read(Vec::len)
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn state(&self, slot: Slot) -> MediaState {
self.read(|slots| {
slots
.iter()
.find(|entry| entry.medium.slot().slot() == slot)
.map_or(MediaState::EMPTY, |entry| {
MediaState(entry.state.load(Ordering::Relaxed))
})
})
}
pub fn publish(&self, slot: Slot, state: MediaState) {
self.read(|slots| {
if let Some(entry) = slots
.iter()
.find(|entry| entry.medium.slot().slot() == slot)
{
entry.state.store(state.0, Ordering::Relaxed);
}
});
}
pub fn publish_all(&self, state: MediaState) {
self.read(|slots| {
for entry in slots {
entry.state.store(state.0, Ordering::Relaxed);
}
});
}
fn read<T>(&self, with: impl FnOnce(&Vec<Entry>) -> T) -> T {
match self.slots.read() {
Ok(slots) => with(&slots),
Err(poisoned) => with(&poisoned.into_inner()),
}
}
fn write<T>(&self, with: impl FnOnce(&mut Vec<Entry>) -> T) -> T {
match self.slots.write() {
Ok(mut slots) => with(&mut slots),
Err(poisoned) => with(&mut poisoned.into_inner()),
}
}
}
impl MediaSource for MediaSet {
fn occupied_slots(&self) -> std::collections::BTreeSet<Slot> {
self.read(|slots| {
slots
.iter()
.filter(|entry| MediaState(entry.state.load(Ordering::Relaxed)).has_media())
.map(|entry| entry.medium.slot().slot())
.collect()
})
}
fn describe(&self, slot: Slot) -> Option<MediaDescription> {
if !self.state(slot).has_media() {
return None;
}
Some(self.get(slot)?.description())
}
fn slot_state(&self, slot: Slot) -> MediaState {
self.state(slot)
}
fn settings(&self, slot: Slot) -> Vec<u8> {
self.get(slot)
.map(|medium| medium.settings().to_vec())
.unwrap_or_default()
}
}
const SPIN_DOWN: Duration = Duration::from_millis(1500);
const UMNT_GRACE: Duration = Duration::from_secs(1);
const EMPTY_HOLD: Duration = Duration::from_millis(600);
const UMNT_POLL: Duration = Duration::from_millis(25);
fn graft(vfs: &Arc<RwLock<Vfs>>, medium: &Medium) -> Result<()> {
if medium.root().is_none() {
return Ok(());
}
let mounted = with_vfs_mut(vfs, |tree| tree.mount_medium(medium))
.map_err(Error::io("walking a medium"))?;
info!(
slot = %medium.slot().slot(),
export = medium.slot().export_path(),
files = mounted,
volume = medium.volume_name(),
tracks = medium.track_count(),
plain = medium.is_plain(),
"mounted a medium",
);
Ok(())
}
fn with_vfs_mut<T>(vfs: &Arc<RwLock<Vfs>>, write: impl FnOnce(&mut Vfs) -> T) -> T {
match vfs.write() {
Ok(mut tree) => write(&mut tree),
Err(poisoned) => write(&mut poisoned.into_inner()),
}
}
#[derive(Debug)]
pub struct VirtualPlayer {
dbserver: DbServer,
nfs: NfsServer,
cdj: VirtualCdj,
discovery: Discovery,
media: Arc<MediaSet>,
vfs: Arc<RwLock<Vfs>>,
}
impl VirtualPlayer {
pub async fn start(
config: VirtualPlayerConfig,
media: impl IntoIterator<Item = Arc<Medium>>,
) -> Result<Self> {
let media = Arc::new(MediaSet::new(media));
let vfs = Arc::new(RwLock::new(Vfs::new()));
for medium in media.all() {
graft(&vfs, &medium)?;
}
let nfs = NfsServer::start(
Arc::clone(&vfs),
NfsConfig {
interface: Some(config.interface.clone()),
portmap_port: config.portmap_port,
..NfsConfig::default()
},
)
.await?;
if !nfs.ports().is_discoverable() {
warn!(
portmap = nfs.ports().portmap,
"the portmapper is not on 111; a real player will retry GETPORT for ever and \
never find us"
);
}
let discovery = Discovery::start(config.interface.clone()).await?;
tokio::time::sleep(crate::discovery::SCAN_DURATION).await;
let source: Arc<dyn MediaSource> = Arc::<MediaSet>::clone(&media);
let cdj = VirtualCdj::start(
&discovery,
VirtualCdjConfig {
name: config.name,
kind: config.kind,
numbering: Numbering::Claim {
preferred: config.preferred_number,
},
generation: config.generation,
emit_status: true,
..VirtualCdjConfig::default()
},
source,
)
.await?;
let device = cdj
.browsable_number()
.ok_or_else(|| Error::NoBrowsableNumber {
taken: discovery.numbers_seen().into_iter().collect(),
})?;
let dbserver = DbServer::start_watching(
DbServerConfig {
device,
address: Ipv4Addr::UNSPECIFIED,
..DbServerConfig::default()
},
Arc::clone(&media),
cdj.loaded(),
)
.await?;
info!(
device = %device,
slots = media.all().len(),
dbserver = dbserver.port(),
"serving",
);
Ok(Self {
dbserver,
nfs,
cdj,
discovery,
media,
vfs,
})
}
pub fn mount(&self, medium: Arc<Medium>) -> Result<()> {
graft(&self.vfs, &medium)?;
self.media.insert(medium);
Ok(())
}
pub fn preserve_track(&self, preserve: &mut Preserve, slot: Slot, track_id: u32) -> usize {
let Some(medium) = self.media.get(slot) else {
return 0;
};
let Some(root) = medium.root() else {
return 0;
};
let wanted = medium.track_files(track_id);
if wanted.is_empty() {
return 0;
}
medium.warm(track_id);
let before = preserve.len();
let prefix = medium.slot().vfs_prefix();
for relative in wanted {
preserve.keep(&format!("/{prefix}/{relative}"), &root.join(&relative));
}
preserve.len() - before
}
pub fn go_phantom(&self, slot: Slot, preserve: &Preserve) -> Preserved {
let Some(medium) = self.media.get(slot) else {
return Preserved::default();
};
medium.go_phantom();
let result = with_vfs_mut(&self.vfs, |tree| {
tree.preserve(medium.slot().vfs_prefix(), preserve.copies())
});
info!(
slot = %slot,
volume = medium.volume_name(),
kept = result.kept,
dropped = result.dropped,
"the medium is gone; serving what a player is still using from a copy",
);
result
}
pub fn is_phantom(&self, slot: Slot) -> bool {
self.media
.get(slot)
.is_some_and(|medium| medium.is_phantom())
}
pub async fn unmount(&self, slot: Slot) {
if self.media.get(slot).is_none() {
return;
}
self.eject(slot).await;
let Some(medium) = self.media.remove(slot) else {
return;
};
with_vfs_mut(&self.vfs, |tree| {
tree.unmount(medium.slot().vfs_prefix());
});
info!(slot = %slot, "unmounted a medium");
}
async fn eject(&self, slot: Slot) {
if self.nfs.mounts().is_empty() {
self.media.publish(slot, MediaState::EMPTY);
return;
}
self.media.publish(slot, MediaState::UNMOUNTING);
tokio::time::sleep(SPIN_DOWN).await;
self.media.publish(slot, MediaState::UNMOUNTING_ALT);
let _ = self.await_unmounts().await;
self.media.publish(slot, MediaState::EMPTY);
}
pub async fn shutdown(self) {
let held = self.nfs.mounts();
if held.is_empty() {
info!("nothing has mounted us; stopping");
self.media.publish_all(MediaState::EMPTY);
tokio::time::sleep(EMPTY_HOLD).await;
} else {
let peers: std::collections::BTreeSet<_> =
held.iter().map(|mount| mount.peer).collect();
info!(
mounts = held.len(),
?peers,
"ejecting our media so the players reading it can let go",
);
self.media.publish_all(MediaState::UNMOUNTING);
tokio::time::sleep(SPIN_DOWN).await;
self.media.publish_all(MediaState::UNMOUNTING_ALT);
let released = self.await_unmounts().await;
self.media.publish_all(MediaState::EMPTY);
if released {
info!("every mount was released");
} else {
warn!(
still_held = self.nfs.mounts().len(),
"some mounts were not released in {} ms; going anyway",
UMNT_GRACE.as_millis(),
);
}
tokio::time::sleep(EMPTY_HOLD).await;
}
drop(self.dbserver);
drop(self.nfs);
drop(self.cdj);
drop(self.discovery);
info!("stopped");
}
async fn await_unmounts(&self) -> bool {
let deadline = tokio::time::Instant::now() + UMNT_GRACE;
while tokio::time::Instant::now() < deadline {
if self.nfs.mounts().is_empty() {
return true;
}
tokio::time::sleep(UMNT_POLL).await;
}
self.nfs.mounts().is_empty()
}
pub fn device_number(&self) -> BrowsableDeviceNumber {
self.cdj.browsable_number().unwrap_or_else(|| {
debug_assert!(false, "a running server always holds a browsable number");
BrowsableDeviceNumber::new(1).unwrap_or_else(unreachable_number)
})
}
pub fn nfs_ports(&self) -> Ports {
self.nfs.ports()
}
pub fn dbserver_port(&self) -> u16 {
self.dbserver.port()
}
pub fn is_discoverable(&self) -> bool {
self.nfs.ports().is_discoverable()
}
pub fn consumers(&self) -> Vec<(u8, Slot, u32)> {
self.cdj.loaded().consumers()
}
pub fn media(&self) -> &MediaSet {
&self.media
}
pub fn cdj(&self) -> &VirtualCdj {
&self.cdj
}
pub fn discovery(&self) -> &Discovery {
&self.discovery
}
pub fn vfs(&self) -> &Arc<RwLock<Vfs>> {
&self.vfs
}
}
fn unreachable_number() -> BrowsableDeviceNumber {
const ONE: Option<BrowsableDeviceNumber> = BrowsableDeviceNumber::new(1);
match ONE {
Some(number) => number,
None => ONE.unwrap_or_else(unreachable_number),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::serve::ServedSlot;
use prolink_rekordbox::Library;
fn library() -> Library {
let raw = std::fs::read(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../../testdata/export.pdb"
))
.expect("the committed export");
Library::parse(&raw).expect("it parses")
}
#[test]
fn a_media_set_reports_only_the_slots_it_has() {
let usb = Arc::new(Medium::synthetic(ServedSlot::USB, library(), "MY STICK"));
let set = MediaSet::new([usb]);
assert_eq!(set.occupied_slots(), [Slot::USB].into_iter().collect());
assert!(
set.describe(Slot::SD).is_none(),
"an empty slot gets no reply at all"
);
let description = set.describe(Slot::USB).expect("the USB is described");
assert_eq!(description.volume_name, "MY STICK");
assert_eq!(
description.track_count, 651,
"the true count, or a deck will not offer it"
);
}
#[test]
fn a_second_medium_in_a_slot_replaces_the_first() {
let first = Arc::new(Medium::synthetic(ServedSlot::USB, library(), "FIRST"));
let second = Arc::new(Medium::synthetic(ServedSlot::USB, library(), "SECOND"));
let set = MediaSet::new([first, second]);
assert_eq!(set.all().len(), 1);
assert_eq!(
set.describe(Slot::USB).map(|d| d.volume_name).as_deref(),
Some("SECOND")
);
}
#[test]
fn a_stick_can_be_plugged_in_and_pulled_out_while_the_player_runs() {
let set = MediaSet::new([]);
assert!(set.is_empty());
assert!(set.occupied_slots().is_empty());
set.insert(Arc::new(Medium::synthetic(
ServedSlot::USB,
library(),
"PLUGGED IN",
)));
assert_eq!(set.occupied_slots(), [Slot::USB].into_iter().collect());
assert_eq!(
set.describe(Slot::USB)
.map(|found| found.volume_name)
.as_deref(),
Some("PLUGGED IN")
);
let taken = set.remove(Slot::USB).expect("it was there");
assert_eq!(taken.volume_name(), "PLUGGED IN");
assert!(set.is_empty());
assert!(
set.describe(Slot::USB).is_none(),
"a pulled stick must not still be offered"
);
assert!(
set.remove(Slot::USB).is_none(),
"and removing it twice is not an error"
);
}
#[test]
fn a_slot_being_ejected_is_not_offered_afresh() {
let set = MediaSet::new([Arc::new(Medium::synthetic(
ServedSlot::USB,
library(),
"GOING",
))]);
set.publish(Slot::USB, MediaState::UNMOUNTING_ALT);
assert!(set.occupied_slots().is_empty());
assert!(set.describe(Slot::USB).is_none());
assert_eq!(
set.all().len(),
1,
"still ours until it is removed, so the eject can finish"
);
}
#[test]
fn two_media_are_two_slots_and_two_subtrees() {
let usb = Arc::new(Medium::synthetic(ServedSlot::USB, library(), "USB"));
let sd = Arc::new(Medium::synthetic(ServedSlot::SD, library(), "SD"));
let set = MediaSet::new([usb, sd]);
assert_eq!(
set.occupied_slots(),
[Slot::USB, Slot::SD].into_iter().collect()
);
assert_ne!(
ServedSlot::USB.vfs_prefix(),
ServedSlot::SD.vfs_prefix(),
"or their filehandles would collide once a CDJ truncates them",
);
}
#[test]
fn a_served_slot_starts_loaded() {
let usb = Arc::new(Medium::synthetic(ServedSlot::USB, library(), "MY STICK"));
let set = MediaSet::new([usb]);
assert_eq!(set.state(Slot::USB), MediaState::LOADED);
assert_eq!(
set.state(Slot::SD),
MediaState::EMPTY,
"a slot with no medium has no state to publish but empty"
);
}
#[test]
fn an_ejecting_slot_publishes_its_state_and_stops_describing_itself() {
let usb = Arc::new(Medium::synthetic(ServedSlot::USB, library(), "MY STICK"));
let set = MediaSet::new([usb]);
for state in [
MediaState::UNMOUNTING,
MediaState::UNMOUNTING_ALT,
MediaState::EMPTY,
] {
set.publish(Slot::USB, state);
assert_eq!(
set.slot_state(Slot::USB),
state,
"the status packet has to carry the state a consumer reacts to"
);
assert!(
set.occupied_slots().is_empty(),
"a medium on its way out is not a medium a deck should reach for"
);
assert!(
set.describe(Slot::USB).is_none(),
"and describing it is what would make the deck offer it again"
);
}
}
#[test]
fn ejecting_publishes_every_slot_at_once() {
let usb = Arc::new(Medium::synthetic(ServedSlot::USB, library(), "USB"));
let sd = Arc::new(Medium::synthetic(ServedSlot::SD, library(), "SD"));
let set = MediaSet::new([usb, sd]);
set.publish_all(MediaState::UNMOUNTING_ALT);
assert_eq!(set.state(Slot::USB), MediaState::UNMOUNTING_ALT);
assert_eq!(set.state(Slot::SD), MediaState::UNMOUNTING_ALT);
}
#[test]
fn a_slot_we_do_not_serve_cannot_be_published_into() {
let usb = Arc::new(Medium::synthetic(ServedSlot::USB, library(), "MY STICK"));
let set = MediaSet::new([usb]);
set.publish(Slot::SD, MediaState::LOADED);
assert_eq!(
set.state(Slot::SD),
MediaState::EMPTY,
"or we would announce an SD card that does not exist"
);
assert!(set.describe(Slot::SD).is_none());
}
#[test]
fn the_eject_dwells_are_the_ones_hardware_uses() {
assert_eq!(SPIN_DOWN, Duration::from_millis(1500));
assert!(
UMNT_GRACE > Duration::from_millis(16),
"the observed reply took 16 ms; a grace shorter than that is no grace"
);
assert!(
EMPTY_HOLD >= Duration::from_millis(600),
"three status packets, so a lost one does not cost the deck the news"
);
}
}