use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
use std::time::Duration;
use prolink_proto::dbserver::{
self, Arguments, Descriptor, Drill, Field, ItemType, MenuItem, MenuTarget, Message,
MessageKind, SortOrder, TrackType,
};
use prolink_proto::{BrowsableDeviceNumber, DeviceNumber, Slot};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tracing::{debug, trace, warn};
use crate::{Error, Result};
pub const NOT_FOUND: u32 = 0xFFFF_FFFF;
pub const ROOT_MENU_MASK: u32 = 0x00FF_FFFF;
pub const WAVEFORM_PREVIEW_ARGUMENT1: u32 = 3;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct DbConfig {
pub connect_timeout: Duration,
pub request_timeout: Duration,
pub batch: u32,
}
impl Default for DbConfig {
fn default() -> Self {
Self {
connect_timeout: Duration::from_secs(5),
request_timeout: Duration::from_secs(10),
batch: dbserver::MAX_RENDER_BATCH,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Analysis {
WaveformPreview,
WaveformDetail,
BeatGrid,
CuePoints,
ExtendedCuePoints,
VbrIndex,
}
impl Analysis {
pub fn request(self) -> MessageKind {
match self {
Self::WaveformPreview => MessageKind::GET_WAVEFORM_PREVIEW,
Self::WaveformDetail => MessageKind::GET_WAVEFORM_DETAIL,
Self::BeatGrid => MessageKind::GET_BEAT_GRID,
Self::CuePoints => MessageKind::GET_CUE_POINTS,
Self::ExtendedCuePoints => MessageKind::GET_CUE_POINTS_EXT,
Self::VbrIndex => MessageKind::GET_VBR_INDEX,
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct TrackMetadata {
pub id: u32,
pub title: String,
pub artwork_id: u32,
pub artist: String,
pub artist_id: u32,
pub album: String,
pub album_id: u32,
pub genre: String,
pub genre_id: u32,
pub key: String,
pub key_id: u32,
pub label: String,
pub label_id: u32,
pub colour: String,
pub colour_id: u32,
pub comment: String,
pub date_added: String,
pub duration_seconds: u32,
pub tempo_centibpm: u32,
pub rating: u32,
pub bitrate: u32,
pub items: Vec<MenuItem>,
}
impl TrackMetadata {
pub fn tempo(&self) -> f64 {
f64::from(self.tempo_centibpm) / 100.0
}
pub fn duration(&self) -> Duration {
Duration::from_secs(u64::from(self.duration_seconds))
}
pub fn from_items(id: u32, items: Vec<MenuItem>) -> Self {
let mut out = Self {
id,
..Self::default()
};
for item in &items {
let text = item.label1.clone();
match item.item_type.masked() {
ItemType::TRACK_TITLE => {
out.title = text;
out.artwork_id = item.artwork_id;
}
ItemType::ARTIST => {
out.artist = text;
out.artist_id = item.id;
}
ItemType::ALBUM => {
out.album = text;
out.album_id = item.id;
}
ItemType::GENRE => {
out.genre = text;
out.genre_id = item.id;
}
ItemType::KEY => {
out.key = text;
out.key_id = item.id;
}
ItemType::LABEL => {
out.label = text;
out.label_id = item.id;
}
ItemType::COLOR => {
out.colour = text;
out.colour_id = item.id;
}
ItemType::COMMENT => out.comment = text,
ItemType::DATE_ADDED => out.date_added = text,
ItemType::DURATION => out.duration_seconds = item.id,
ItemType::TEMPO => out.tempo_centibpm = item.id,
ItemType::RATING => out.rating = item.id,
ItemType::BITRATE => out.bitrate = item.id,
other => trace!(?other, "an unnamed metadata item"),
}
}
out.items = items;
out
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TrackInfo {
pub id: u32,
pub path: String,
pub size: u64,
pub container: u32,
pub duration_seconds: u32,
pub tempo_centibpm: u32,
pub comment: String,
pub plain_lookup: Option<(u32, u32)>,
pub items: Vec<MenuItem>,
}
impl TrackInfo {
pub fn from_items(id: u32, items: Vec<MenuItem>) -> Option<Self> {
let path_item = items
.iter()
.find(|item| item.item_type.masked() == ItemType::PATH)?;
let mut out = Self {
id,
path: path_item.label1.clone(),
size: u64::from(path_item.argument0),
container: 0,
duration_seconds: 0,
tempo_centibpm: 0,
comment: String::new(),
plain_lookup: None,
items: Vec::new(),
};
let (mut folder, mut entry) = (None, None);
for item in &items {
match item.item_type.masked() {
ItemType::TRACK_TITLE => {
out.container = item.id;
folder = Some(item.argument0);
}
ItemType::DURATION => {
out.duration_seconds = item.id;
entry = Some(item.argument0);
}
ItemType::TEMPO => out.tempo_centibpm = item.id,
ItemType::COMMENT => out.comment.clone_from(&item.label1),
_ => {}
}
}
if out.path.is_empty()
&& let (Some(folder), Some(entry)) = (folder, entry)
{
out.plain_lookup = Some((folder, entry));
}
out.items = items;
Some(out)
}
}
const MAX_BUFFER: usize = 8 * 1024 * 1024;
const READ_CHUNK: usize = 16 * 1024;
#[derive(Debug)]
pub struct DbClient {
stream: TcpStream,
peer: Ipv4Addr,
port: u16,
device: BrowsableDeviceNumber,
server: DeviceNumber,
config: DbConfig,
buffer: Vec<u8>,
consumed: usize,
transaction: u32,
desynchronised: bool,
}
impl DbClient {
pub async fn query_port(peer: Ipv4Addr, timeout: Duration) -> Result<u16> {
Self::query_port_at(peer, dbserver::PORT_QUERY_PORT, timeout).await
}
pub async fn query_port_at(peer: Ipv4Addr, query_port: u16, timeout: Duration) -> Result<u16> {
let address = SocketAddr::V4(SocketAddrV4::new(peer, query_port));
let mut stream = tokio::time::timeout(timeout, TcpStream::connect(address))
.await
.map_err(|_| Error::Timeout {
what: "connecting to the dbserver port query",
after: timeout,
})?
.map_err(Error::io("connecting to the dbserver port query"))?;
stream
.write_all(&dbserver::PORT_QUERY)
.await
.map_err(Error::io("sending the dbserver port query"))?;
let mut answer = [0u8; 2];
tokio::time::timeout(timeout, stream.read_exact(&mut answer))
.await
.map_err(|_| Error::Timeout {
what: "the dbserver port query",
after: timeout,
})?
.map_err(Error::io("reading the dbserver port answer"))?;
let port = dbserver::decode_port_reply(&answer)?;
if port == 0 {
return Err(Error::Refused {
what: "the dbserver port query",
detail: "the player answered port 0, which is not a port".to_owned(),
});
}
debug!(%peer, port, "dbserver port");
Ok(port)
}
pub async fn connect(peer: Ipv4Addr, device: BrowsableDeviceNumber) -> Result<Self> {
let config = DbConfig::default();
let port = Self::query_port(peer, config.connect_timeout).await?;
Self::connect_at(peer, port, device, config).await
}
pub async fn connect_at(
peer: Ipv4Addr,
port: u16,
device: BrowsableDeviceNumber,
config: DbConfig,
) -> Result<Self> {
let address = SocketAddr::V4(SocketAddrV4::new(peer, port));
let stream = tokio::time::timeout(config.connect_timeout, TcpStream::connect(address))
.await
.map_err(|_| Error::Timeout {
what: "connecting to a dbserver",
after: config.connect_timeout,
})?
.map_err(Error::io("connecting to a dbserver"))?;
let mut client = Self {
stream,
peer,
port,
device,
server: DeviceNumber::ONE,
config,
buffer: Vec::with_capacity(READ_CHUNK),
consumed: 0,
transaction: dbserver::FIRST_TRANSACTION_ID,
desynchronised: false,
};
let mut opening = dbserver::PREAMBLE.to_vec();
opening.extend_from_slice(&Message::introduce(device).encode());
client
.stream
.write_all(&opening)
.await
.map_err(Error::io("opening a dbserver session"))?;
client.expect_preamble().await?;
client.server = client.expect_introduce_reply().await?;
debug!(%peer, port, server = %client.server, "dbserver session open");
Ok(client)
}
pub fn peer(&self) -> Ipv4Addr {
self.peer
}
pub fn port(&self) -> u16 {
self.port
}
pub fn device(&self) -> BrowsableDeviceNumber {
self.device
}
pub fn server(&self) -> DeviceNumber {
self.server
}
pub fn is_desynchronised(&self) -> bool {
self.desynchronised
}
pub fn descriptor(&self, slot: Slot, menu: MenuTarget, track_type: TrackType) -> Descriptor {
Descriptor::new(self.device, slot, menu, track_type)
}
pub async fn close(mut self) -> Result<()> {
let farewell = Message::disconnect().encode();
let _ = self.stream.write_all(&farewell).await;
let _ = self.stream.shutdown().await;
Ok(())
}
pub async fn root_menu(&mut self, slot: Slot) -> Result<Vec<MenuItem>> {
let descriptor = self.main(slot);
self.menu(
MessageKind::MENU_ROOT,
descriptor,
&[SortOrder::DEFAULT.0, ROOT_MENU_MASK],
)
.await
}
pub async fn sort_menu(&mut self, slot: Slot, menu: MessageKind) -> Result<Vec<MenuItem>> {
let descriptor = self.main(slot);
self.menu(
MessageKind::MENU_SORT,
descriptor,
&[SortOrder::DEFAULT.0, u32::from(menu.0)],
)
.await
}
pub async fn category(
&mut self,
slot: Slot,
kind: MessageKind,
sort: SortOrder,
) -> Result<Vec<MenuItem>> {
let descriptor = self.main(slot);
self.menu(kind, descriptor, &[sort.0]).await
}
pub async fn tracks(&mut self, slot: Slot, sort: SortOrder) -> Result<Vec<MenuItem>> {
self.category(slot, MessageKind::MENU_TRACK, sort).await
}
pub async fn playlist(
&mut self,
slot: Slot,
id: u32,
folder: bool,
sort: SortOrder,
) -> Result<Vec<MenuItem>> {
let descriptor = self.main(slot);
self.menu(
MessageKind::MENU_PLAYLIST,
descriptor,
&[sort.0, id, u32::from(folder)],
)
.await
}
pub async fn drill(
&mut self,
slot: Slot,
drill: Drill,
sort: SortOrder,
filters: &[u32],
) -> Result<Vec<MenuItem>> {
let descriptor = self.main(slot);
let mut extra = Vec::with_capacity(filters.len().saturating_add(1));
extra.push(sort.0);
extra.extend_from_slice(filters);
self.menu(drill.kind(), descriptor, &extra).await
}
pub async fn folder(&mut self, slot: Slot, id: u32) -> Result<Vec<MenuItem>> {
let descriptor = self.descriptor(slot, MenuTarget::MAIN, TrackType::UNANALYSED);
self.menu(
MessageKind::MENU_FOLDER,
descriptor,
&[SortOrder::DEFAULT.0, id, 0],
)
.await
}
pub async fn search(
&mut self,
slot: Slot,
term: &str,
sort: SortOrder,
) -> Result<Vec<MenuItem>> {
let descriptor = self.main(slot);
let request = Message::search(
self.next_transaction(),
descriptor,
sort,
&term.to_uppercase(),
);
self.paged(request, descriptor).await
}
pub async fn metadata(&mut self, slot: Slot, track_id: u32) -> Result<TrackMetadata> {
let descriptor = self.descriptor(slot, MenuTarget::SUB, TrackType::REKORDBOX);
let items = self
.menu(MessageKind::GET_METADATA, descriptor, &[track_id])
.await?;
Ok(TrackMetadata::from_items(track_id, items))
}
pub async fn track_info(&mut self, slot: Slot, track_id: u32) -> Result<TrackInfo> {
let descriptor = self.descriptor(slot, MenuTarget::BINARY, TrackType::REKORDBOX);
let items = self
.menu(MessageKind::GET_TRACK_INFO, descriptor, &[track_id])
.await?;
TrackInfo::from_items(track_id, items).ok_or(Error::Refused {
what: "a dbserver GET_TRACK_INFO",
detail: format!("track {track_id} came back with no path item, so it cannot be loaded"),
})
}
pub async fn generic_metadata(&mut self, slot: Slot, file_id: u32) -> Result<TrackMetadata> {
let descriptor = self.descriptor(slot, MenuTarget::SUB, TrackType::UNANALYSED);
let items = self
.menu(MessageKind::GET_GENERIC_METADATA, descriptor, &[file_id])
.await?;
Ok(TrackMetadata::from_items(file_id, items))
}
pub async fn plain_track_info(&mut self, slot: Slot, file_id: u32) -> Result<TrackInfo> {
let descriptor = self.descriptor(slot, MenuTarget::BINARY, TrackType::UNANALYSED);
let items = self
.menu(MessageKind::GET_TRACK_INFO, descriptor, &[file_id])
.await?;
TrackInfo::from_items(file_id, items)
.filter(|info| info.plain_lookup.is_some())
.ok_or(Error::Refused {
what: "a dbserver GET_TRACK_INFO",
detail: format!("file {file_id} came back with no numbers to open it by"),
})
}
pub async fn plain_artwork(&mut self, slot: Slot, file_id: u32) -> Result<Vec<u8>> {
let descriptor = self.descriptor(slot, MenuTarget::BINARY, TrackType::UNANALYSED);
let request = self.binary_request(MessageKind::GET_ARTWORK, descriptor, &[file_id])?;
let reply = self.request(request).await?;
Ok(blob_of(&reply))
}
pub async fn artwork(&mut self, slot: Slot, artwork_id: u32) -> Result<Vec<u8>> {
let descriptor = self.binary(slot);
let request = self.binary_request(MessageKind::GET_ARTWORK, descriptor, &[artwork_id])?;
let reply = self.request(request).await?;
Ok(blob_of(&reply))
}
pub async fn analysis(
&mut self,
slot: Slot,
track_id: u32,
which: Analysis,
) -> Result<Vec<u8>> {
let request = match which {
Analysis::WaveformPreview => {
let descriptor = self.binary(slot);
Message::new(
self.next_transaction(),
MessageKind::GET_WAVEFORM_PREVIEW,
Arguments::from([
Field::from(descriptor),
Field::U32(WAVEFORM_PREVIEW_ARGUMENT1),
Field::U32(track_id),
Field::U32(0),
Field::Blob(Vec::new()),
]),
)
}
Analysis::WaveformDetail => {
let descriptor = self.main(slot);
Message::new(
self.next_transaction(),
MessageKind::GET_WAVEFORM_DETAIL,
Arguments::from([Field::from(descriptor), Field::U32(track_id), Field::U32(0)]),
)
}
other => {
let descriptor = self.binary(slot);
self.binary_request(other.request(), descriptor, &[track_id])?
}
};
let reply = self.request(request).await?;
Ok(blob_of(&reply))
}
pub async fn menu(
&mut self,
kind: MessageKind,
descriptor: Descriptor,
extra: &[u32],
) -> Result<Vec<MenuItem>> {
let request = Message::menu_request(self.next_transaction(), kind, descriptor, extra)
.ok_or(Error::Refused {
what: "a dbserver menu request",
detail: format!(
"{} arguments is more than the twelve a header can describe",
extra.len().saturating_add(1)
),
})?;
self.paged(request, descriptor).await
}
async fn paged(&mut self, request: Message, descriptor: Descriptor) -> Result<Vec<MenuItem>> {
let kind = request.kind;
let reply = self.request(request).await?;
if reply.kind != MessageKind::SUCCESS {
return Err(Error::Refused {
what: "a dbserver menu request",
detail: format!("{kind:?} was answered with {:?}", reply.kind),
});
}
let count = reply.number(1).unwrap_or(0);
if count == NOT_FOUND {
debug!(?kind, "the player has nothing under that");
return Ok(Vec::new());
}
self.render(descriptor, count).await
}
async fn render(&mut self, descriptor: Descriptor, count: u32) -> Result<Vec<MenuItem>> {
let mut items = Vec::with_capacity(usize::try_from(count).unwrap_or(0));
let mut offset = 0;
let mut last = None;
while offset < count {
let limit = self.config.batch.min(count - offset).max(1);
let transaction = self.next_transaction();
let render = Message::render_of(transaction, descriptor, offset, limit, count);
self.send(&render).await?;
items.extend(self.read_page(transaction).await?);
offset = offset.saturating_add(limit);
last = Some(transaction);
}
if let Some(transaction) = last {
self.close_menu(transaction).await?;
}
Ok(items)
}
async fn read_page(&mut self, transaction: u32) -> Result<Vec<MenuItem>> {
let mut items = Vec::new();
loop {
let message = self.recv().await?;
if message.transaction_id != transaction {
return Err(self.desynchronise(transaction, &message));
}
match message.kind {
MessageKind::MENU_HEADER => {}
MessageKind::MENU_FOOTER => return Ok(items),
MessageKind::MENU_ITEM => match MenuItem::from_message(&message) {
Some(item) => items.push(item),
None => {
return Err(Error::Refused {
what: "a dbserver menu item",
detail: format!("a 0x4101 that does not decode as a row: {message:?}"),
});
}
},
MessageKind::ERROR => {
return Err(Error::Refused {
what: "a dbserver render",
detail: format!("the player refused mid-page: {message:?}"),
});
}
other => trace!(?other, "an unexpected message inside a menu page"),
}
}
}
async fn close_menu(&mut self, transaction: u32) -> Result<()> {
let close = Message::new(transaction, MessageKind::MENU_CLOSE, []);
debug_assert!(
close.kind.expects_no_reply(),
"MENU_CLOSE is the one message with no answer"
);
self.send(&close).await
}
pub async fn request(&mut self, message: Message) -> Result<Message> {
if message.kind.expects_no_reply() {
return Err(Error::Refused {
what: "a dbserver request",
detail: format!("{:?} draws no reply and must not be awaited", message.kind),
});
}
let transaction = message.transaction_id;
let kind = message.kind;
self.send(&message).await?;
let reply = self.recv().await?;
if reply.transaction_id != transaction {
return Err(self.desynchronise(transaction, &reply));
}
if reply.kind == MessageKind::ERROR {
return Err(Error::Refused {
what: "a dbserver request",
detail: format!("the player refused {kind:?}: {reply:?}"),
});
}
Ok(reply)
}
async fn send(&mut self, message: &Message) -> Result<()> {
if self.desynchronised {
return Err(Error::Refused {
what: "a dbserver request",
detail: "this connection lost track of the stream and cannot recover".to_owned(),
});
}
trace!(?message, "->");
self.stream
.write_all(&message.encode())
.await
.map_err(Error::io("sending a dbserver message"))
}
async fn recv(&mut self) -> Result<Message> {
loop {
if let Some(message) = self.take_message()? {
trace!(?message, "<-");
return Ok(message);
}
self.fill().await?;
}
}
fn take_message(&mut self) -> Result<Option<Message>> {
let pending = self.buffer.get(self.consumed..).unwrap_or_default();
if pending.is_empty() {
return Ok(None);
}
match Message::decode(pending) {
Ok((message, used)) => {
self.consumed = self.consumed.saturating_add(used);
self.compact();
Ok(Some(message))
}
Err(error) if error.is_truncated() => Ok(None),
Err(error) => {
self.desynchronised = true;
Err(error.into())
}
}
}
fn compact(&mut self) {
if self.consumed == self.buffer.len() {
self.buffer.clear();
self.consumed = 0;
} else if self.consumed >= READ_CHUNK {
self.buffer.drain(..self.consumed);
self.consumed = 0;
}
}
async fn fill(&mut self) -> Result<()> {
if self.buffer.len() >= MAX_BUFFER {
self.desynchronised = true;
return Err(Error::Refused {
what: "a dbserver reply",
detail: format!("{MAX_BUFFER} bytes arrived without completing one message"),
});
}
let start = self.buffer.len();
self.buffer.resize(start.saturating_add(READ_CHUNK), 0);
let target = self.buffer.get_mut(start..).unwrap_or_default();
let outcome =
tokio::time::timeout(self.config.request_timeout, self.stream.read(target)).await;
let read = match outcome {
Ok(Ok(read)) => read,
Ok(Err(error)) => {
self.buffer.truncate(start);
return Err(Error::io("reading from a dbserver")(error));
}
Err(_elapsed) => {
self.buffer.truncate(start);
return Err(Error::Timeout {
what: "a dbserver reply",
after: self.config.request_timeout,
});
}
};
self.buffer.truncate(start.saturating_add(read));
if read == 0 {
return Err(Error::Refused {
what: "a dbserver reply",
detail: "the player closed the connection".to_owned(),
});
}
Ok(())
}
async fn expect_preamble(&mut self) -> Result<()> {
while self.buffer.len() < dbserver::PREAMBLE.len() {
self.fill().await?;
}
if self.buffer.get(..dbserver::PREAMBLE.len()) != Some(&dbserver::PREAMBLE[..]) {
self.desynchronised = true;
return Err(Error::Refused {
what: "a dbserver connection",
detail: format!(
"the peer opened with {:02x?}, not the five-byte preamble",
self.buffer.get(..dbserver::PREAMBLE.len())
),
});
}
self.consumed = dbserver::PREAMBLE.len();
self.compact();
Ok(())
}
async fn expect_introduce_reply(&mut self) -> Result<DeviceNumber> {
let reply = self.recv().await?;
if reply.transaction_id != dbserver::SETUP_TRANSACTION_ID {
return Err(self.desynchronise(dbserver::SETUP_TRANSACTION_ID, &reply));
}
if reply.kind != MessageKind::SUCCESS {
return Err(Error::Refused {
what: "a dbserver INTRODUCE",
detail: format!("the player answered {:?}", reply.kind),
});
}
let raw = reply.number(1).unwrap_or(0);
DeviceNumber::new(u8::try_from(raw).unwrap_or(0)).ok_or(Error::Refused {
what: "a dbserver INTRODUCE",
detail: format!("the player called itself device {raw}"),
})
}
fn desynchronise(&mut self, wanted: u32, got: &Message) -> Error {
self.desynchronised = true;
warn!(
wanted = format!("{wanted:#x}"),
got = format!("{:#x}", got.transaction_id),
"dbserver replies are out of step"
);
Error::Refused {
what: "a dbserver reply",
detail: format!(
"expected transaction {wanted:#x}, got {:#x}; the stream has no framing to \
resynchronise on",
got.transaction_id
),
}
}
fn next_transaction(&mut self) -> u32 {
let transaction = self.transaction;
self.transaction = self
.transaction
.checked_add(1)
.unwrap_or(dbserver::FIRST_TRANSACTION_ID);
transaction
}
fn main(&self, slot: Slot) -> Descriptor {
self.descriptor(slot, MenuTarget::MAIN, TrackType::REKORDBOX)
}
fn binary(&self, slot: Slot) -> Descriptor {
self.descriptor(slot, MenuTarget::BINARY, TrackType::REKORDBOX)
}
fn binary_request(
&mut self,
kind: MessageKind,
descriptor: Descriptor,
extra: &[u32],
) -> Result<Message> {
Message::menu_request(self.next_transaction(), kind, descriptor, extra).ok_or(
Error::Refused {
what: "a dbserver binary request",
detail: format!("{kind:?} needs more arguments than a message can carry"),
},
)
}
}
fn blob_of(reply: &Message) -> Vec<u8> {
if let Some(blob) = reply.blob(3) {
return blob.to_vec();
}
reply
.args
.as_slice()
.iter()
.find_map(Field::blob)
.unwrap_or_default()
.to_vec()
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::{Arc, Mutex};
use prolink_proto::dbserver::{FIRST_TRANSACTION_ID, ROOT_CATEGORIES};
use tokio::net::TcpListener;
fn us() -> BrowsableDeviceNumber {
BrowsableDeviceNumber::new(1).expect("device 1 is browsable")
}
fn hex(text: &str) -> Vec<u8> {
let digits: Vec<char> = text.chars().filter(|c| !c.is_whitespace()).collect();
assert!(
digits.len().is_multiple_of(2),
"a hex literal needs an even length"
);
digits
.chunks_exact(2)
.map(|pair| {
let byte: String = pair.iter().collect();
u8::from_str_radix(&byte, 16).expect("a hex literal must be hex")
})
.collect()
}
#[derive(Clone, Debug)]
struct Library {
rows: Vec<MenuItem>,
metadata: Vec<MenuItem>,
track_info: Vec<MenuItem>,
artwork: Vec<u8>,
force_count: Option<u32>,
wrong_transaction: bool,
deaf: bool,
}
impl Default for Library {
fn default() -> Self {
Self {
rows: ROOT_CATEGORIES.iter().map(|c| c.to_item()).collect(),
metadata: metadata_rows(),
track_info: track_info_rows(),
artwork: Vec::new(),
force_count: None,
wrong_transaction: false,
deaf: false,
}
}
}
fn metadata_rows() -> Vec<MenuItem> {
vec![
MenuItem {
argument0: 1,
id: 0xc8,
label1: "Loneliness - Klub Cut".to_owned(),
label2: String::new(),
item_type: ItemType::TRACK_TITLE,
flags: MenuItem::TRACK_FLAGS,
artwork_id: 0xba,
playlist_position: 0,
key_index: 0,
},
MenuItem::named(0x7a, ItemType::ARTIST, "Tomcraft"),
MenuItem::named(0x56, ItemType::ALBUM, "Loneliness"),
MenuItem::named(0x1d7, ItemType::DURATION, ""),
MenuItem::named(0x3391, ItemType::TEMPO, ""),
MenuItem::named(
0xc8,
ItemType::COMMENT,
"https://music.youtube.com/watch?v=6gnPFu8KD74",
),
MenuItem::named(9, ItemType::KEY, "12A"),
MenuItem::named(3, ItemType::RATING, ""),
MenuItem::named(0, ItemType::COLOR, ""),
]
}
fn track_info_rows() -> Vec<MenuItem> {
vec![
MenuItem::named(1, ItemType::TRACK_TITLE, ""),
MenuItem::named(0x1d7, ItemType::DURATION, ""),
MenuItem::named(0x3391, ItemType::TEMPO, ""),
MenuItem::named(
0xc8,
ItemType::COMMENT,
"https://music.youtube.com/watch?v=6gnPFu8KD74",
),
MenuItem {
argument0: 0x0074_7a7b,
id: 0xc8,
label1: "/Contents/Tomcraft/Loneliness/Tomcraft - Loneliness - Klub Cut.mp3"
.to_owned(),
label2: String::new(),
item_type: ItemType::PATH,
flags: 0,
artwork_id: 0,
playlist_position: 0,
key_index: 0,
},
MenuItem::named(1, ItemType::TRACK_INFO_UNKNOWN, ""),
]
}
#[derive(Debug)]
struct Player {
port: u16,
query_port: u16,
seen: Arc<Mutex<Vec<Message>>>,
tasks: Vec<tokio::task::JoinHandle<()>>,
}
impl Drop for Player {
fn drop(&mut self) {
for task in &self.tasks {
task.abort();
}
}
}
impl Player {
fn requests(&self) -> Vec<Message> {
match self.seen.lock() {
Ok(seen) => seen.clone(),
Err(poisoned) => poisoned.into_inner().clone(),
}
}
fn of_kind(&self, kind: MessageKind) -> Vec<Message> {
self.requests()
.into_iter()
.filter(|message| message.kind == kind)
.collect()
}
}
async fn listener() -> (TcpListener, u16) {
let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
.await
.expect("an ephemeral loopback listener");
let port = match listener.local_addr().expect("a bound listener") {
SocketAddr::V4(address) => address.port(),
SocketAddr::V6(_) => unreachable!("bound as IPv4"),
};
(listener, port)
}
async fn player(library: Library) -> Player {
let (dbserver_listener, port) = listener().await;
let (query_listener, query_port) = listener().await;
let seen = Arc::new(Mutex::new(Vec::new()));
let mut tasks = Vec::new();
tasks.push(tokio::spawn(async move {
while let Ok((mut socket, _)) = query_listener.accept().await {
let mut query = [0u8; dbserver::PORT_QUERY.len()];
if socket.read_exact(&mut query).await.is_err() {
continue;
}
assert_eq!(query, dbserver::PORT_QUERY, "the fixed 19-byte query");
let _ = socket.write_all(&dbserver::encode_port_reply(port)).await;
}
}));
let log = Arc::clone(&seen);
tasks.push(tokio::spawn(async move {
while let Ok((socket, _)) = dbserver_listener.accept().await {
let library = library.clone();
let log = Arc::clone(&log);
tokio::spawn(serve(socket, library, log));
}
}));
Player {
port,
query_port,
seen,
tasks,
}
}
async fn serve(mut socket: TcpStream, library: Library, log: Arc<Mutex<Vec<Message>>>) {
if library.deaf {
std::future::pending::<()>().await;
}
if socket.write_all(&dbserver::PREAMBLE).await.is_err() {
return;
}
let mut opening = [0u8; dbserver::PREAMBLE.len()];
if socket.read_exact(&mut opening).await.is_err() {
return;
}
assert_eq!(
opening,
dbserver::PREAMBLE,
"a client must open with the five-byte preamble"
);
let mut buffer = Vec::new();
let mut chunk = [0u8; 4096];
loop {
let mut consumed = 0usize;
while let Ok((message, used)) = Message::decode(&buffer[consumed..]) {
consumed += used;
match log.lock() {
Ok(mut seen) => seen.push(message.clone()),
Err(poisoned) => poisoned.into_inner().push(message.clone()),
}
for reply in answer(&message, &library) {
if socket.write_all(&reply.encode()).await.is_err() {
return;
}
}
}
buffer.drain(..consumed);
match socket.read(&mut chunk).await {
Ok(0) | Err(_) => return,
Ok(read) => buffer.extend_from_slice(&chunk[..read]),
}
}
}
fn answer(message: &Message, library: &Library) -> Vec<Message> {
let transaction = if library.wrong_transaction {
message.transaction_id ^ 0xFFFF
} else {
message.transaction_id
};
match message.kind {
MessageKind::INTRODUCE => vec![Message {
transaction_id: transaction,
..Message::introduce_reply(DeviceNumber::new(2).unwrap_or(DeviceNumber::ONE))
}],
MessageKind::DISCONNECT | MessageKind::MENU_CLOSE => Vec::new(),
MessageKind::RENDER_MENU => render_page(message, library, transaction),
MessageKind::GET_ARTWORK => Message::binary_reply(
transaction,
MessageKind::ARTWORK,
MessageKind::GET_ARTWORK,
library.artwork.clone(),
&[],
)
.into_iter()
.collect(),
MessageKind::GET_WAVEFORM_PREVIEW
| MessageKind::GET_WAVEFORM_DETAIL
| MessageKind::GET_BEAT_GRID
| MessageKind::GET_CUE_POINTS
| MessageKind::GET_CUE_POINTS_EXT
| MessageKind::GET_VBR_INDEX => Message::binary_reply(
transaction,
MessageKind::WAVEFORM_PREVIEW,
message.kind,
vec![7; 16],
&[],
)
.into_iter()
.collect(),
kind => {
let count = library
.force_count
.unwrap_or_else(|| default_count(kind, library));
vec![Message::success(transaction, kind, count)]
}
}
}
fn render_page(render: &Message, library: &Library, transaction: u32) -> Vec<Message> {
let offset = render.number(1).unwrap_or(0);
let limit = render.number(2).unwrap_or(0);
let total = render.number(4).unwrap_or(0);
let rows = rows_for(render, library, total);
let mut page = vec![Message::menu_header(transaction)];
for index in offset..offset.saturating_add(limit).min(total) {
let position = usize::try_from(index).unwrap_or(0) % rows.len().max(1);
let row = rows
.get(position)
.cloned()
.unwrap_or_else(|| MenuItem::named(index, ItemType::TRACK_TITLE, "row"));
page.push(row.to_message(transaction));
}
page.push(Message::menu_footer(transaction));
page
}
fn default_count(kind: MessageKind, library: &Library) -> u32 {
let rows = match kind {
MessageKind::GET_METADATA => library.metadata.len(),
MessageKind::GET_TRACK_INFO => library.track_info.len(),
_ => library.rows.len(),
};
u32::try_from(rows).unwrap_or(0)
}
fn rows_for(render: &Message, library: &Library, total: u32) -> Vec<MenuItem> {
let target = render.descriptor().map(|descriptor| descriptor.menu);
if target == Some(MenuTarget::SUB) && total == count_of(&library.metadata) {
return library.metadata.clone();
}
if target == Some(MenuTarget::BINARY) && total == count_of(&library.track_info) {
return library.track_info.clone();
}
library.rows.clone()
}
fn count_of(rows: &[MenuItem]) -> u32 {
u32::try_from(rows.len()).unwrap_or(0)
}
async fn connect(player: &Player) -> DbClient {
DbClient::connect_at(Ipv4Addr::LOCALHOST, player.port, us(), quick())
.await
.expect("connecting to the loopback player")
}
fn quick() -> DbConfig {
DbConfig {
connect_timeout: Duration::from_secs(2),
request_timeout: Duration::from_secs(2),
..DbConfig::default()
}
}
#[tokio::test]
async fn the_port_query_is_nineteen_bytes_and_the_answer_is_two() {
let player = player(Library::default()).await;
let port = DbClient::query_port_at(
Ipv4Addr::LOCALHOST,
player.query_port,
Duration::from_secs(2),
)
.await
.expect("the port query");
assert_eq!(port, player.port);
assert_eq!(dbserver::PORT_QUERY.len(), 19);
assert_eq!(
dbserver::PORT_QUERY.get(..4),
Some([0x00, 0x00, 0x00, 0x0f].as_slice()),
"a big-endian 15: fourteen name bytes plus the NUL"
);
}
#[tokio::test]
async fn introduce_reports_the_players_own_number_not_an_item_count() {
let player = player(Library::default()).await;
let client = connect(&player).await;
assert_eq!(client.server().get(), 2);
assert_eq!(client.device().get(), 1);
let requests = player.requests();
assert_eq!(
requests.first().map(|message| message.kind),
Some(MessageKind::INTRODUCE)
);
assert_eq!(
requests.first().map(|message| message.transaction_id),
Some(dbserver::SETUP_TRANSACTION_ID),
"INTRODUCE has its own reserved id"
);
}
#[tokio::test]
async fn a_transaction_id_starts_where_a_real_players_does() {
let player = player(Library::default()).await;
let mut client = connect(&player).await;
client.root_menu(Slot::USB).await.expect("root menu");
let ids: Vec<u32> = player
.requests()
.iter()
.map(|message| message.transaction_id)
.filter(|id| *id != dbserver::SETUP_TRANSACTION_ID)
.collect();
assert_eq!(ids.first(), Some(&FIRST_TRANSACTION_ID));
assert_eq!(FIRST_TRANSACTION_ID, 0x0380_0001);
assert!(
ids.windows(2).all(|pair| pair[0] <= pair[1]),
"and counts up: {ids:#x?}"
);
}
#[tokio::test]
async fn a_menu_larger_than_one_render_is_paged() {
let player = player(Library {
force_count: Some(150),
..Library::default()
})
.await;
let mut client = connect(&player).await;
let items = client
.tracks(Slot::USB, SortOrder::DEFAULT)
.await
.expect("tracks");
assert_eq!(items.len(), 150);
let renders = player.of_kind(MessageKind::RENDER_MENU);
assert_eq!(renders.len(), 3, "150 rows at 64 a render is three pages");
assert_eq!(renders.first().and_then(|m| m.number(1)), Some(0));
assert_eq!(renders.first().and_then(|m| m.number(2)), Some(64));
assert_eq!(renders.get(2).and_then(|m| m.number(1)), Some(128));
assert_eq!(
renders.get(2).and_then(|m| m.number(2)),
Some(22),
"the last page asks only for what is left"
);
}
#[tokio::test]
async fn every_render_echoes_the_whole_result_set_size_not_the_page_size() {
let player = player(Library {
force_count: Some(150),
..Library::default()
})
.await;
let mut client = connect(&player).await;
client
.tracks(Slot::USB, SortOrder::DEFAULT)
.await
.expect("tracks");
for render in player.of_kind(MessageKind::RENDER_MENU) {
assert_eq!(render.number(4), Some(150), "argument 4 is the total");
}
}
#[tokio::test]
async fn menu_close_reuses_the_last_renders_transaction_id_and_draws_no_reply() {
let player = player(Library {
force_count: Some(150),
..Library::default()
})
.await;
let mut client = connect(&player).await;
client
.tracks(Slot::USB, SortOrder::DEFAULT)
.await
.expect("tracks");
client.root_menu(Slot::USB).await.expect("still in step");
let requests = player.requests();
let follow_up = requests
.iter()
.position(|message| message.kind == MessageKind::MENU_ROOT)
.expect("the follow-up menu");
let closes: Vec<&Message> = requests[..follow_up]
.iter()
.filter(|message| message.kind == MessageKind::MENU_CLOSE)
.collect();
assert_eq!(closes.len(), 1, "one per menu, after its last page");
let close = closes.first().expect("a close");
let last_render = requests[..follow_up]
.iter()
.rev()
.find(|message| message.kind == MessageKind::RENDER_MENU)
.map(|message| message.transaction_id);
assert_eq!(
Some(close.transaction_id),
last_render,
"the third page's id"
);
assert!(close.args.is_empty(), "zero arguments, 32 bytes");
}
#[tokio::test]
async fn a_count_of_ffffffff_is_an_empty_menu_and_not_an_error() {
let player = player(Library {
force_count: Some(NOT_FOUND),
..Library::default()
})
.await;
let mut client = connect(&player).await;
let items = client
.drill(
Slot::USB,
Drill {
depth: 1,
category: 0x01,
},
SortOrder::DEFAULT,
&[9999],
)
.await
.expect("not found is not a failure");
assert!(items.is_empty());
assert!(
player.of_kind(MessageKind::RENDER_MENU).is_empty(),
"nothing to page, so nothing is paged"
);
}
#[tokio::test]
async fn an_empty_menu_and_a_refused_request_do_not_look_the_same() {
let player = player(Library {
force_count: Some(0),
..Library::default()
})
.await;
let mut client = connect(&player).await;
assert!(
client
.category(Slot::USB, MessageKind::MENU_GENRE, SortOrder::DEFAULT)
.await
.expect("an empty category is a success")
.is_empty()
);
}
#[tokio::test]
async fn the_root_menu_comes_back_wrapped_for_localisation() {
let player = player(Library::default()).await;
let mut client = connect(&player).await;
let items = client.root_menu(Slot::USB).await.expect("root menu");
assert_eq!(items.len(), ROOT_CATEGORIES.len());
let first = items.first().expect("a first row");
assert_eq!(
dbserver::unwrap_menu_label(&first.label1),
Some("PLAYLIST"),
"a bare label renders and is then not openable (F26)"
);
assert_eq!(first.flags, 0, "category rows carry no track flags");
}
#[tokio::test]
async fn a_playlist_folder_and_a_playlist_differ_by_one_argument() {
let player = player(Library::default()).await;
let mut client = connect(&player).await;
client
.playlist(Slot::USB, 0, true, SortOrder::DEFAULT)
.await
.expect("the playlist root");
client
.playlist(Slot::USB, 3, false, SortOrder::DEFAULT)
.await
.expect("a playlist");
let requests = player.of_kind(MessageKind::MENU_PLAYLIST);
assert_eq!(requests.first().and_then(|m| m.number(3)), Some(1));
assert_eq!(requests.get(1).and_then(|m| m.number(2)), Some(3));
assert_eq!(requests.get(1).and_then(|m| m.number(3)), Some(0));
}
#[tokio::test]
async fn metadata_is_read_by_item_type_and_the_ids_are_the_rows_it_references() {
let player = player(Library::default()).await;
let mut client = connect(&player).await;
let track = client.metadata(Slot::USB, 0xc8).await.expect("metadata");
assert_eq!(track.title, "Loneliness - Klub Cut");
assert_eq!(track.artist, "Tomcraft");
assert_eq!(
track.artist_id, 0x7a,
"the artist's own id, not the track's — that is what lets a caller \
offer 'more by this artist' (F32)"
);
assert_eq!(track.album_id, 0x56);
assert_eq!(
track.artwork_id, 0xba,
"off the title item; without it a player never asks for the cover"
);
assert_eq!(track.duration_seconds, 471);
assert_eq!(track.tempo_centibpm, 13_201);
assert!((track.tempo() - 132.01).abs() < 1e-9);
assert_eq!(track.rating, 3);
assert_eq!(track.key, "12A");
assert_eq!(track.items.len(), 9);
assert_eq!(
player
.of_kind(MessageKind::GET_METADATA)
.first()
.and_then(Message::descriptor)
.map(|d| d.menu),
Some(MenuTarget::SUB),
"the transient menu, so the list being scrolled is undisturbed"
);
}
#[tokio::test]
async fn a_track_the_player_does_not_have_is_empty_rather_than_an_error() {
let player = player(Library {
force_count: Some(NOT_FOUND),
..Library::default()
})
.await;
let mut client = connect(&player).await;
let track = client.metadata(Slot::USB, 12_345).await.expect("no error");
assert_eq!(track.id, 12_345);
assert!(track.title.is_empty() && track.items.is_empty());
}
fn plain_track_info_rows(folder: u32, entry: u32) -> Vec<MenuItem> {
let mut container = MenuItem::named(1, ItemType::TRACK_TITLE, "");
container.argument0 = folder;
let mut duration = MenuItem::named(60, ItemType::DURATION, "");
duration.argument0 = entry;
let mut path = MenuItem::named(0, ItemType::PATH, "");
path.argument0 = 1_453_552;
vec![
container,
duration,
MenuItem::named(12_500, ItemType::TEMPO, ""),
MenuItem::named(4, ItemType::COMMENT, ""),
path,
]
}
#[test]
fn a_plain_answer_is_told_by_its_empty_path_whatever_its_numbers() {
let info = TrackInfo::from_items(4, plain_track_info_rows(1, 4)).expect("five rows");
assert_eq!(info.plain_lookup, Some((1, 4)));
assert_eq!(info.size, 1_453_552);
let first = TrackInfo::from_items(2, plain_track_info_rows(2, 0)).expect("five rows");
assert_eq!(first.plain_lookup, Some((2, 0)));
let rekordbox = TrackInfo::from_items(0xc8, track_info_rows()).expect("six rows");
assert_eq!(rekordbox.plain_lookup, None);
}
#[tokio::test]
async fn track_info_takes_the_file_size_from_argument_zero_of_the_path_item() {
let player = player(Library::default()).await;
let mut client = connect(&player).await;
let info = client
.track_info(Slot::USB, 0xc8)
.await
.expect("track info");
assert_eq!(info.size, 7_633_531);
assert_eq!(
info.path, "/Contents/Tomcraft/Loneliness/Tomcraft - Loneliness - Klub Cut.mp3",
"already relative to the mount root, ready for NfsClient::open"
);
assert_eq!(info.duration_seconds, 471);
}
#[tokio::test]
async fn the_same_type_byte_is_the_title_in_metadata_and_the_container_in_track_info() {
let player = player(Library::default()).await;
let mut client = connect(&player).await;
let metadata = client.metadata(Slot::USB, 0xc8).await.expect("metadata");
let info = client
.track_info(Slot::USB, 0xc8)
.await
.expect("track info");
assert_eq!(metadata.title, "Loneliness - Klub Cut");
assert_eq!(info.container, 1, "an id, and an empty label beside it");
assert!(
!info.items.iter().any(|item| item.label1 == metadata.title),
"nothing in a track-info reply carries the title"
);
}
#[tokio::test]
async fn a_track_with_no_artwork_answers_with_an_omitted_blob_and_that_is_success() {
let player = player(Library::default()).await;
let mut client = connect(&player).await;
let art = client
.artwork(Slot::USB, 0)
.await
.expect("no art is not an error");
assert!(art.is_empty());
assert_eq!(
player
.of_kind(MessageKind::GET_ARTWORK)
.first()
.and_then(Message::descriptor)
.map(|d| d.menu),
Some(MenuTarget::BINARY),
"artwork is a binary load"
);
}
#[tokio::test]
async fn artwork_bytes_come_back_whole() {
let player = player(Library {
artwork: vec![0xab; 2740],
..Library::default()
})
.await;
let mut client = connect(&player).await;
let art = client.artwork(Slot::USB, 0xba).await.expect("artwork");
assert_eq!(art.len(), 2740, "the size of a real cover in the corpus");
assert_eq!(art.first(), Some(&0xab));
}
#[tokio::test]
async fn the_waveform_preview_carries_its_track_id_at_argument_two() {
let player = player(Library::default()).await;
let mut client = connect(&player).await;
client
.analysis(Slot::USB, 0xc8, Analysis::WaveformPreview)
.await
.expect("preview");
let request = player
.of_kind(MessageKind::GET_WAVEFORM_PREVIEW)
.first()
.cloned()
.expect("a preview request");
assert_eq!(request.args.len(), 5, "five declared");
assert_eq!(request.number(1), Some(3));
assert_eq!(
request.number(2),
Some(0xc8),
"not argument 1 like its siblings"
);
assert_eq!(request.number(3), Some(0));
assert_eq!(request.blob(4), Some(&[][..]));
assert_eq!(
request.encode().len(),
32 + 4 * 5,
"four on the wire: the trailing blob is omitted entirely"
);
}
#[tokio::test]
async fn the_detailed_waveform_uses_the_main_target_where_its_siblings_use_binary() {
let player = player(Library::default()).await;
let mut client = connect(&player).await;
for which in [
Analysis::WaveformDetail,
Analysis::BeatGrid,
Analysis::CuePoints,
Analysis::VbrIndex,
] {
client
.analysis(Slot::USB, 0xc8, which)
.await
.expect("analysis");
}
let targets: Vec<(MessageKind, Option<MenuTarget>)> = player
.requests()
.iter()
.filter(|message| message.kind.0 & 0xf000 == 0x2000)
.map(|message| (message.kind, message.descriptor().map(|d| d.menu)))
.collect();
assert!(targets.contains(&(MessageKind::GET_WAVEFORM_DETAIL, Some(MenuTarget::MAIN))));
assert!(targets.contains(&(MessageKind::GET_BEAT_GRID, Some(MenuTarget::BINARY))));
assert!(targets.contains(&(MessageKind::GET_VBR_INDEX, Some(MenuTarget::BINARY))));
}
#[tokio::test]
async fn a_reply_under_the_wrong_transaction_id_ends_the_connection() {
let player = player(Library {
wrong_transaction: true,
..Library::default()
})
.await;
let error = DbClient::connect_at(Ipv4Addr::LOCALHOST, player.port, us(), quick())
.await
.expect_err("the handshake must not proceed");
assert!(error.to_string().contains("transaction"), "{error}");
}
#[tokio::test]
async fn a_silent_player_times_out_rather_than_hanging() {
let player = player(Library {
deaf: true,
..Library::default()
})
.await;
let started = std::time::Instant::now();
let error = DbClient::connect_at(
Ipv4Addr::LOCALHOST,
player.port,
us(),
DbConfig {
connect_timeout: Duration::from_millis(200),
request_timeout: Duration::from_millis(200),
..DbConfig::default()
},
)
.await
.expect_err("a deaf player must not hang");
assert!(matches!(error, Error::Timeout { .. }), "{error:?}");
assert!(started.elapsed() < Duration::from_secs(3));
}
#[tokio::test]
async fn menu_close_cannot_be_awaited() {
let player = player(Library::default()).await;
let mut client = connect(&player).await;
let error = client
.request(Message::new(1, MessageKind::MENU_CLOSE, []))
.await
.expect_err("waiting for a reply to this hangs a real session");
assert!(error.to_string().contains("draws no reply"), "{error}");
}
#[tokio::test]
async fn saying_goodbye_sends_the_disconnect_a_deck_sends() {
let player = player(Library::default()).await;
let client = connect(&player).await;
client.close().await.expect("goodbye");
tokio::time::sleep(Duration::from_millis(50)).await;
assert_eq!(player.of_kind(MessageKind::DISCONNECT).len(), 1);
}
fn deck(slot: Slot, menu: MenuTarget, track_type: TrackType, device: u8) -> Descriptor {
Descriptor::new(
BrowsableDeviceNumber::new(device).expect("a browsable number"),
slot,
menu,
track_type,
)
}
#[test]
fn our_root_menu_request_is_byte_for_byte_a_real_one() {
let captured = hex(
"11872349ae11038003201010000f03140000000c060606000000000000000000\
110101030111000000001100ffffff",
);
let descriptor = deck(Slot::USB, MenuTarget::MAIN, TrackType::REKORDBOX, 1);
assert_eq!(descriptor.to_raw(), 0x0101_0301);
let ours = Message::menu_request(
0x0380_0320,
MessageKind::MENU_ROOT,
descriptor,
&[SortOrder::DEFAULT.0, ROOT_MENU_MASK],
)
.expect("three arguments");
assert_eq!(ours.encode(), captured);
}
#[test]
fn our_render_is_byte_for_byte_a_real_one() {
let captured = hex(
"11872349ae11038003211030000f06140000000c060606060606000000000000\
1101010301110000000011000000061100000000110000000c1100000000",
);
let ours = Message::render_of(
0x0380_0321,
deck(Slot::USB, MenuTarget::MAIN, TrackType::REKORDBOX, 1),
0,
6,
12,
);
assert_eq!(ours.encode(), captured);
assert_eq!(
ours.number(4),
Some(12),
"the whole result set, not the page"
);
}
#[test]
fn our_menu_close_is_byte_for_byte_a_real_one() {
let captured = hex("11872349ae11038003291000010f00140000000c000000000000000000000000");
let ours = Message::new(0x0380_0329, MessageKind::MENU_CLOSE, []);
assert_eq!(ours.encode(), captured);
assert_eq!(captured.len(), 32);
}
#[test]
fn our_metadata_and_track_info_requests_are_byte_for_byte_real_ones() {
let metadata = hex(
"11872349ae11038003651020020f02140000000c060600000000000000000000\
110102030111000000c8",
);
assert_eq!(
Message::menu_request(
0x0380_0365,
MessageKind::GET_METADATA,
deck(Slot::USB, MenuTarget::SUB, TrackType::REKORDBOX, 1),
&[0xc8],
)
.expect("two arguments")
.encode(),
metadata,
"metadata is fetched through the transient menu target"
);
let track_info = hex(
"11872349ae110380036a1021020f02140000000c060600000000000000000000\
110108030111000000c8",
);
assert_eq!(
Message::menu_request(
0x0380_036a,
MessageKind::GET_TRACK_INFO,
deck(Slot::USB, MenuTarget::BINARY, TrackType::REKORDBOX, 1),
&[0xc8],
)
.expect("two arguments")
.encode(),
track_info
);
}
#[test]
fn our_artwork_request_is_byte_for_byte_a_real_one() {
let captured = hex(
"11872349ae11038003671020030f02140000000c060600000000000000000000\
110108030111000000ba",
);
assert_eq!(
Message::menu_request(
0x0380_0367,
MessageKind::GET_ARTWORK,
deck(Slot::USB, MenuTarget::BINARY, TrackType::REKORDBOX, 1),
&[0xba],
)
.expect("two arguments")
.encode(),
captured
);
}
#[test]
fn our_waveform_preview_request_is_byte_for_byte_a_real_one() {
let captured = hex(
"11872349ae110380036c1020040f05140000000c060606060300000000000000\
1101080301110000000311000000c81100000000",
);
let ours = Message::new(
0x0380_036c,
MessageKind::GET_WAVEFORM_PREVIEW,
Arguments::from([
Field::from(deck(Slot::USB, MenuTarget::BINARY, TrackType::REKORDBOX, 1)),
Field::U32(WAVEFORM_PREVIEW_ARGUMENT1),
Field::U32(0xc8),
Field::U32(0),
Field::Blob(Vec::new()),
]),
);
assert_eq!(ours.encode(), captured);
}
#[test]
fn our_drill_requests_are_byte_for_byte_real_ones() {
let descriptor = deck(Slot::USB, MenuTarget::SUB, TrackType::REKORDBOX, 2);
assert_eq!(descriptor.to_raw(), 0x0202_0301);
let genre = 0x01;
let depth1 = hex(
"11872349ae11038005801011010f03140000000c060606000000000000000000\
110202030111000000001100000004",
);
assert_eq!(
drill_message(0x0380_0580, descriptor, genre, 1, &[4]).encode(),
depth1
);
let depth2 = hex(
"11872349ae110380059b1012010f04140000000c060606060000000000000000\
11020203011100000000110000000611ffffffff",
);
assert_eq!(
drill_message(
0x0380_059b,
descriptor,
genre,
2,
&[6, dbserver::FILTER_ALL]
)
.encode(),
depth2
);
let depth3 = hex(
"11872349ae11038005a31013010f05140000000c060606060600000000000000\
110202030111000000001100000006110000002611ffffffff",
);
assert_eq!(
drill_message(
0x0380_05a3,
descriptor,
genre,
3,
&[6, 0x26, dbserver::FILTER_ALL]
)
.encode(),
depth3
);
}
fn drill_message(
transaction: u32,
descriptor: Descriptor,
category: u8,
depth: u8,
filters: &[u32],
) -> Message {
let mut extra = vec![SortOrder::DEFAULT.0];
extra.extend_from_slice(filters);
Message::menu_request(
transaction,
Drill { depth, category }.kind(),
descriptor,
&extra,
)
.expect("a drill fits")
}
#[test]
fn our_sort_menu_request_is_byte_for_byte_a_real_one() {
let captured = hex(
"11872349ae11038008c71014000f03140000000c060606000000000000000000\
110205030111000000001100001105",
);
let ours = Message::menu_request(
0x0380_08c7,
MessageKind::MENU_SORT,
Descriptor::new(
BrowsableDeviceNumber::new(2).expect("browsable"),
Slot::USB,
MenuTarget(0x05),
TrackType::REKORDBOX,
),
&[
SortOrder::DEFAULT.0,
u32::from(MessageKind::MENU_PLAYLIST.0),
],
)
.expect("three arguments");
assert_eq!(ours.encode(), captured);
}
#[test]
fn our_search_request_is_byte_for_byte_a_real_one() {
let captured = hex(
"11872349ae11038008171013000f05140000000c060606020600000000000000\
1102010301110000000011000000042600000002004800001100000000",
);
let ours = Message::search(
0x0380_0817,
deck(Slot::USB, MenuTarget::MAIN, TrackType::REKORDBOX, 2),
SortOrder::DEFAULT,
"H",
);
assert_eq!(ours.encode(), captured);
assert_eq!(
ours.number(2),
Some(4),
"one character plus the NUL, doubled"
);
assert_eq!(ours.text(3), Some("H"));
}
#[test]
fn our_track_list_request_is_byte_for_byte_a_real_one() {
let captured = hex(
"11872349ae11038006e51010040f02140000000c060600000000000000000000\
11020203011100000000",
);
let ours = Message::menu_request(
0x0380_06e5,
MessageKind::MENU_TRACK,
deck(Slot::USB, MenuTarget::SUB, TrackType::REKORDBOX, 2),
&[SortOrder::DEFAULT.0],
)
.expect("two arguments");
assert_eq!(ours.encode(), captured);
}
#[test]
fn the_batch_size_is_the_one_documented_safe_on_a_nexus_2() {
assert_eq!(DbConfig::default().batch, 64);
assert_eq!(dbserver::MAX_RENDER_BATCH, 64);
}
#[test]
fn a_track_info_with_no_path_cannot_be_built() {
assert!(TrackInfo::from_items(1, Vec::new()).is_none());
assert!(TrackInfo::from_items(1, vec![MenuItem::named(1, ItemType::TEMPO, "")]).is_none());
assert!(TrackInfo::from_items(1, track_info_rows()).is_some());
}
#[test]
fn an_item_type_is_masked_before_it_is_matched() {
let mut rows = metadata_rows();
for row in &mut rows {
row.item_type = ItemType(row.item_type.0 | 0x00ab_0000);
}
let track = TrackMetadata::from_items(0xc8, rows);
assert_eq!(track.title, "Loneliness - Klub Cut");
assert_eq!(track.tempo_centibpm, 13_201);
}
#[test]
fn a_binary_reply_with_no_payload_reads_as_empty_not_as_missing() {
let reply = Message::binary_reply(
1,
MessageKind::ARTWORK,
MessageKind::GET_ARTWORK,
Vec::new(),
&[],
)
.expect("four arguments");
assert_eq!(reply.number(2), Some(0), "the length argument says zero");
assert!(blob_of(&reply).is_empty());
let full = Message::binary_reply(
1,
MessageKind::ARTWORK,
MessageKind::GET_ARTWORK,
vec![1, 2, 3],
&[],
)
.expect("four arguments");
assert_eq!(blob_of(&full), vec![1, 2, 3]);
}
}