feat: add a controller-driven Subsonic player for SteamOS

Browses a Subsonic library and plays it through mpv, driven by a
gamepad or keyboard. The UI scales from the window's physical height
rather than the compositor's scale factor, so it keeps its proportions
on a Steam Deck and on a 4K TV, where other players open small or
scale badly.
This commit is contained in:
Ansho Rei
2026-11-04 01:17:29 +01:00
commit 4105554f68
14 changed files with 10825 additions and 0 deletions
+1
View File
@@ -0,0 +1 @@
/target
Generated
+6782
View File
File diff suppressed because it is too large Load Diff
+25
View File
@@ -0,0 +1,25 @@
[package]
name = "remus"
version = "0.1.0"
edition = "2024"
[dependencies]
anyhow = "1.0.104"
directories = "6.0.0"
env_logger = "0.11.11"
fontique = { version = "0.11", default-features = false, features = ["fontconfig-dlopen"] }
gilrs = "0.11.2"
image = { version = "0.25.10", default-features = false, features = ["jpeg", "png", "webp"] }
libc = "0.2.191"
log = "0.4.35"
lru = "0.19.0"
md5 = "0.8.1"
reqwest = { version = "0.13.5", default-features = false, features = ["json", "rustls"] }
serde = { version = "1.0.229", features = ["derive"] }
serde_json = "1.0.154"
slint = "1.18.1"
tokio = { version = "1.54.1", features = ["rt-multi-thread", "sync", "macros", "time"] }
toml = "1.1.8"
[build-dependencies]
slint-build = "1.18.1"
+56
View File
@@ -0,0 +1,56 @@
# remus
A controller-first music player for a Subsonic library, built for SteamOS on a Steam Deck or a TV.
It opens fullscreen. Its UI is sized from the window's physical height, not from the scale factor the compositor reports, so it keeps the same proportions at 1280×800 and at 4K. Cover art is requested at the size it is drawn.
## Requirements
- `mpv` on the PATH. remus runs it as a child process and controls it over its JSON IPC socket.
- A Subsonic or OpenSubsonic server (Navidrome, Gonic, Airsonic...).
## Run
```
cargo run --release # fullscreen
cargo run --release -- --windowed
```
On first start remus asks for the server address, username and password. It stores the address, the username and an auth token (md5 of password + salt) in `~/.config/remus/config.toml`, mode 0600. The token is enough to log in to that server, so treat the file as a credential. Delete it to log in again.
Covers are cached in `~/.cache/remus/covers`.
## Controls
| Gamepad | Keyboard | Action |
|---|---|---|
| D-pad / left stick | Arrows | Move |
| A | Enter | Open, play |
| B | Esc, Backspace | Back |
| X | Space | Play / pause |
| Y | Q | Add album, playlist or track to the queue |
| LB / RB | P / N | Previous / next track |
| LT / RT | Shift+Tab / Tab | Previous / next section |
| Right stick | , / . | Seek 10 s |
| Menu | F | Now playing |
| View | / | Search |
| | F11 | Toggle fullscreen |
| | Ctrl+Q | Quit |
With Steam running, remus listens only to Steam's virtual controller, so a pad Steam also exposes does not send every press twice. On a Deck, Steam + X opens the on-screen keyboard for the login and search fields.
## Development
```
cargo test
REMUS_TEST_URL=https://demo.navidrome.org REMUS_TEST_USER=demo REMUS_TEST_PASS=demo \
cargo test -- --ignored # every API call against a real server
```
`REMUS_DEV_SCRIPT` replays actions and saves screenshots, which is how layouts are checked at different sizes without a controller:
```
REMUS_DEV_SCRIPT="size:full,wait:3000,shot:home.png,right,activate,wait:2000,shot:album.png,quit" cargo run
```
Steps: `size:WxH`, `size:full`, `wait:MS`, `shot:PATH`, and action names (`up`, `down`, `left`, `right`, `activate`, `back`, `queue`, `next`, `play-pause`, `section-next`, `now-playing`, `search`, `quit`). Point `XDG_CONFIG_HOME` and `XDG_CACHE_HOME` at a scratch directory to keep test runs away from your own config.
+3
View File
@@ -0,0 +1,3 @@
fn main() {
slint_build::compile("ui/app.slint").expect("compiling ui/app.slint");
}
+1
View File
@@ -0,0 +1 @@
max_width = 120
+1785
View File
File diff suppressed because it is too large Load Diff
+69
View File
@@ -0,0 +1,69 @@
use std::fs;
use std::io::Write;
use std::os::unix::fs::OpenOptionsExt;
use std::path::PathBuf;
use anyhow::{Context, Result};
use directories::ProjectDirs;
use serde::{Deserialize, Serialize};
/// Server credentials. `token` is md5(password + salt): not the password,
/// but enough to log in to this server, so the file is written 0600.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
pub url: String,
pub username: String,
pub salt: String,
pub token: String,
}
fn dirs() -> Option<ProjectDirs> {
ProjectDirs::from("", "", "remus")
}
fn config_path() -> Option<PathBuf> {
dirs().map(|d| d.config_dir().join("config.toml"))
}
pub fn cache_dir() -> Option<PathBuf> {
dirs().map(|d| d.cache_dir().to_path_buf())
}
pub fn load() -> Result<Option<Config>> {
let Some(path) = config_path() else { return Ok(None) };
match fs::read_to_string(&path) {
Ok(text) => Ok(Some(
toml::from_str(&text).with_context(|| format!("parsing {}", path.display()))?,
)),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
Err(e) => Err(e).with_context(|| format!("reading {}", path.display())),
}
}
pub fn save(cfg: &Config) -> Result<()> {
let path = config_path().context("no config directory")?;
if let Some(dir) = path.parent() {
fs::create_dir_all(dir)?;
}
let text = toml::to_string(cfg)?;
// Write aside, sync, then rename over the old file, so a power cut
// mid-save leaves either the old login or the new one, never a torn file.
let tmp = path.with_extension("toml.tmp");
let mut f = fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(&tmp)
.with_context(|| format!("writing {}", tmp.display()))?;
f.write_all(text.as_bytes())?;
f.sync_all()?;
fs::rename(&tmp, &path).with_context(|| format!("replacing {}", path.display()))?;
if let Some(dir) = path.parent()
&& let Ok(d) = fs::File::open(dir)
{
let _ = d.sync_all();
}
log::info!("saved login to {}", path.display());
Ok(())
}
+92
View File
@@ -0,0 +1,92 @@
//! Scripted UI driving for development: replays actions and saves screenshots,
//! so layout can be checked at several resolutions without a controller.
//!
//! REMUS_DEV_SCRIPT="size:1280x800,wait:2000,shot:home.png,right,activate,wait:1500,shot:album.png,quit"
use std::time::Duration;
use slint::{ComponentHandle, PhysicalSize, Timer};
use crate::{Action, AppWindow, app};
pub fn run(ui: &AppWindow, script: &str) {
let steps: Vec<String> = script
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect();
step(ui.as_weak(), steps, 0);
}
fn step(ui: slint::Weak<AppWindow>, steps: Vec<String>, i: usize) {
let Some(cmd) = steps.get(i).cloned() else { return };
let Some(win) = ui.upgrade() else { return };
let mut delay = Duration::from_millis(250);
match cmd.split_once(':') {
Some(("wait", ms)) => delay = Duration::from_millis(ms.parse().unwrap_or(1000)),
Some(("size", "full")) => {
win.window().set_fullscreen(true);
delay = Duration::from_millis(800);
}
Some(("size", wh)) => {
if let Some((w, h)) = wh.split_once('x') {
win.window()
.set_size(PhysicalSize::new(w.parse().unwrap_or(1280), h.parse().unwrap_or(800)));
}
delay = Duration::from_millis(500);
}
Some(("shot", path)) => {
let w = win.window();
log::info!(
"window: {:?} physical, scale factor {}, fullscreen {}, theme scale {}",
w.size(),
w.scale_factor(),
w.is_fullscreen(),
win.global::<crate::Theme>().get_s()
);
match w.take_snapshot() {
Ok(buf) => {
let img = image::RgbaImage::from_raw(buf.width(), buf.height(), buf.as_bytes().to_vec());
match img.map(|img| img.save(path)) {
Some(Ok(())) => log::info!("saved {path} ({}x{})", buf.width(), buf.height()),
Some(Err(e)) => log::error!("saving {path}: {e}"),
None => log::error!("snapshot buffer has the wrong size"),
}
}
Err(e) => log::error!("snapshot failed: {e}"),
}
}
Some(("login", creds)) => {
let mut parts = creds.splitn(3, '|').map(str::to_string);
let (url, user, pass) = (
parts.next().unwrap_or_default(),
parts.next().unwrap_or_default(),
parts.next().unwrap_or_default(),
);
app::with_app(move |app| app.dev_login(&url, &user, &pass));
}
_ => {
let action = match cmd.as_str() {
"up" => Action::Up,
"down" => Action::Down,
"left" => Action::Left,
"right" => Action::Right,
"activate" => Action::Activate,
"back" => Action::Back,
"queue" => Action::Queue,
"next" => Action::Next,
"play-pause" => Action::PlayPause,
"section-next" => Action::SectionNext,
"now-playing" => Action::NowPlaying,
"search" => Action::Search,
"quit" => Action::Quit,
other => {
log::warn!("unknown dev script step {other}");
Action::None
}
};
app::with_app(move |app| app.action(action));
}
}
Timer::single_shot(delay, move || step(ui, steps, i + 1));
}
+175
View File
@@ -0,0 +1,175 @@
//! Gamepad input. Buttons map to the same `Action`s as the keyboard bindings in app.slint.
use std::time::{Duration, Instant};
use gilrs::{Axis, Button, EventType, GamepadId, Gilrs};
use crate::Action;
/// Steam's virtual controllers. When one is present the physical pad behind it
/// also shows up as an evdev device, so only Steam's is listened to.
const STEAM_VENDOR: u16 = 0x28de;
const REPEAT_DELAY: Duration = Duration::from_millis(380);
const REPEAT_SLOW: Duration = Duration::from_millis(110);
const REPEAT_FAST: Duration = Duration::from_millis(45);
const FAST_AFTER: Duration = Duration::from_millis(1500);
const STICK_ON: f32 = 0.55;
const STICK_OFF: f32 = 0.35;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Source {
DPad,
LeftStick,
RightStick,
}
struct Held {
source: Source,
action: Action,
since: Instant,
next: Instant,
}
pub fn spawn_gamepad(emit: impl Fn(Action) + Send + 'static) {
let spawned = std::thread::Builder::new().name("gamepad".into()).spawn(move || {
let mut gilrs = match Gilrs::new() {
Ok(g) => g,
Err(e) => {
log::warn!("gamepad support unavailable: {e}");
return;
}
};
for (_, pad) in gilrs.gamepads() {
log::info!("gamepad: {} (vendor {:04x?})", pad.name(), pad.vendor_id());
}
let mut held: Option<Held> = None;
loop {
while let Some(ev) = gilrs.next_event_blocking(Some(Duration::from_millis(15))) {
if !accept_from(&gilrs, ev.id) {
continue;
}
match ev.event {
EventType::ButtonPressed(b, _) => {
if let Some(a) = dpad_action(b) {
held = Some(start_hold(Source::DPad, a));
emit(a);
} else if let Some(a) = button_action(b) {
emit(a);
}
}
EventType::ButtonReleased(b, _) => {
if dpad_action(b).is_some() && held.as_ref().is_some_and(|h| h.source == Source::DPad) {
held = None;
}
}
EventType::AxisChanged(axis, value, _) => {
let source = match axis {
Axis::LeftStickX | Axis::LeftStickY => Source::LeftStick,
Axis::RightStickX => Source::RightStick,
_ => continue,
};
let pad = gilrs.gamepad(ev.id);
let dir = stick_direction(source, &pad, value, held.as_ref());
match (dir, held.as_ref()) {
(Some(a), Some(h)) if h.source == source && h.action == a => {}
(Some(a), _) => {
held = Some(start_hold(source, a));
emit(a);
}
(None, Some(h)) if h.source == source => held = None,
_ => {}
}
}
EventType::Disconnected => held = None,
_ => {}
}
}
if let Some(h) = held.as_mut() {
let now = Instant::now();
if now >= h.next {
emit(h.action);
let step = if now - h.since > FAST_AFTER {
REPEAT_FAST
} else {
REPEAT_SLOW
};
h.next = now + step;
}
}
}
});
if let Err(e) = spawned {
log::warn!("could not start gamepad thread: {e}");
}
}
fn accept_from(gilrs: &Gilrs, id: GamepadId) -> bool {
let steam_present = gilrs.gamepads().any(|(_, p)| p.vendor_id() == Some(STEAM_VENDOR));
!steam_present || gilrs.gamepad(id).vendor_id() == Some(STEAM_VENDOR)
}
fn start_hold(source: Source, action: Action) -> Held {
let now = Instant::now();
Held {
source,
action,
since: now,
next: now + REPEAT_DELAY,
}
}
fn dpad_action(b: Button) -> Option<Action> {
Some(match b {
Button::DPadUp => Action::Up,
Button::DPadDown => Action::Down,
Button::DPadLeft => Action::Left,
Button::DPadRight => Action::Right,
_ => return None,
})
}
fn button_action(b: Button) -> Option<Action> {
Some(match b {
Button::South => Action::Activate,
Button::East => Action::Back,
Button::West => Action::PlayPause,
Button::North => Action::Queue,
Button::LeftTrigger => Action::Prev,
Button::RightTrigger => Action::Next,
Button::LeftTrigger2 => Action::SectionPrev,
Button::RightTrigger2 => Action::SectionNext,
Button::Start => Action::NowPlaying,
Button::Select => Action::Search,
_ => return None,
})
}
/// Reads the stick's dominant direction, with hysteresis so a stick resting
/// near the threshold does not flicker between held and released.
fn stick_direction(source: Source, pad: &gilrs::Gamepad<'_>, _changed: f32, held: Option<&Held>) -> Option<Action> {
let holding = held.is_some_and(|h| h.source == source);
let threshold = if holding { STICK_OFF } else { STICK_ON };
match source {
Source::LeftStick => {
let x = pad.value(Axis::LeftStickX);
let y = pad.value(Axis::LeftStickY);
if x.abs() < threshold && y.abs() < threshold {
None
} else if x.abs() > y.abs() {
Some(if x > 0.0 { Action::Right } else { Action::Left })
} else {
Some(if y > 0.0 { Action::Up } else { Action::Down })
}
}
Source::RightStick => {
let x = pad.value(Axis::RightStickX);
if x.abs() < threshold {
None
} else {
Some(if x > 0.0 { Action::SeekForward } else { Action::SeekBack })
}
}
Source::DPad => None,
}
}
+64
View File
@@ -0,0 +1,64 @@
slint::include_modules!();
mod app;
mod config;
mod devscript;
mod input;
mod player;
mod subsonic;
use std::time::Duration;
fn main() -> anyhow::Result<()> {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("remus=info")).init();
let dev_script = std::env::var("REMUS_DEV_SCRIPT").ok();
let windowed = std::env::args().any(|a| a == "--windowed") || std::env::var_os("REMUS_WINDOWED").is_some();
let rt = tokio::runtime::Builder::new_multi_thread()
.worker_threads(2)
.enable_all()
.build()?;
let ui = AppWindow::new()?;
app::install(&ui, rt.handle().clone());
input::spawn_gamepad(|action| {
let _ = slint::invoke_from_event_loop(move || app::with_app(move |app| app.action(action)));
});
// Kept alive until the event loop ends.
let fullscreen_retry = slint::Timer::default();
if !windowed {
ui.window().set_fullscreen(true);
// Compositors ignore the request until the window is mapped, and a
// tiling one (COSMIC) can take the window back right after granting
// it. Keep asking until fullscreen has held for a second, giving up
// after five. Then stop, so a later F11 to leave fullscreen sticks.
let weak = ui.as_weak();
let (mut ticks, mut held) = (0, 0);
fullscreen_retry.start(slint::TimerMode::Repeated, Duration::from_millis(100), move || {
let Some(ui) = weak.upgrade() else { return };
if ticks >= 50 || held >= 10 {
return;
}
ticks += 1;
if ui.window().is_fullscreen() {
held += 1;
return;
}
held = 0;
log::debug!("not fullscreen yet ({:?}), asking again", ui.window().size());
ui.window().set_fullscreen(false);
ui.window().set_fullscreen(true);
});
}
if let Some(script) = dev_script {
devscript::run(&ui, &script);
}
ui.run()?;
app::shutdown();
drop(rt);
Ok(())
}
+186
View File
@@ -0,0 +1,186 @@
//! Playback through an mpv child process, controlled over its JSON IPC socket.
use std::io::{BufRead, BufReader, Write};
use std::os::unix::net::UnixStream;
use std::os::unix::process::CommandExt;
use std::path::PathBuf;
use std::process::{Child, Command, Stdio};
use std::sync::Mutex;
use std::time::Duration;
use anyhow::{Context, Result, bail};
use serde_json::{Value, json};
#[derive(Debug, Clone, Copy)]
pub enum PlayerEvent {
Position(f64),
Duration(f64),
Paused(bool),
/// Index into the mpv playlist, None when nothing is loaded.
Track(Option<usize>),
Exited,
}
const OBSERVED: [&str; 4] = ["time-pos", "duration", "pause", "playlist-pos"];
pub struct Player {
writer: Mutex<UnixStream>,
child: Mutex<Child>,
socket: PathBuf,
}
impl Player {
pub fn spawn(on_event: impl Fn(PlayerEvent) + Send + 'static) -> Result<Player> {
let dir = std::env::var_os("XDG_RUNTIME_DIR")
.map(PathBuf::from)
.unwrap_or_else(std::env::temp_dir);
let socket = dir.join(format!("remus-mpv-{}.sock", std::process::id()));
let _ = std::fs::remove_file(&socket);
let mut cmd = Command::new("mpv");
cmd.args([
"--idle=yes",
"--config=no",
"--no-video",
"--no-terminal",
"--audio-display=no",
"--prefetch-playlist=yes",
"--cache=yes",
"--volume=100",
])
.arg(format!("--input-ipc-server={}", socket.display()))
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null());
// Take mpv down with us if we crash, so it never keeps playing orphaned.
unsafe {
cmd.pre_exec(|| {
libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM);
Ok(())
});
}
let mut child = cmd.spawn().context("could not start mpv (is it installed?)")?;
let stream = (0..50).find_map(|_| {
UnixStream::connect(&socket).ok().or_else(|| {
std::thread::sleep(Duration::from_millis(100));
None
})
});
let Some(stream) = stream else {
let _ = child.kill();
bail!("mpv did not open its IPC socket at {}", socket.display());
};
let reader = BufReader::new(stream.try_clone()?);
std::thread::Builder::new().name("mpv-ipc".into()).spawn(move || {
for line in reader.lines() {
let Ok(line) = line else { break };
if let Some(ev) = parse_event(&line) {
on_event(ev);
}
}
on_event(PlayerEvent::Exited);
})?;
let player = Player {
writer: Mutex::new(stream),
child: Mutex::new(child),
socket,
};
for (i, name) in OBSERVED.iter().enumerate() {
player.command(json!(["observe_property", i + 1, name]));
}
Ok(player)
}
fn command(&self, args: Value) {
let mut line = json!({ "command": args }).to_string();
line.push('\n');
if let Ok(mut w) = self.writer.lock()
&& let Err(e) = w.write_all(line.as_bytes())
{
log::warn!("mpv ipc write failed: {e}");
}
}
/// Replaces the playlist with `urls` and starts at `start`.
pub fn play_list(&self, urls: &[String], start: usize) {
self.command(json!(["stop"]));
for url in urls {
self.command(json!(["loadfile", url, "append"]));
}
self.command(json!(["playlist-play-index", start]));
self.command(json!(["set_property", "pause", false]));
}
pub fn append(&self, url: &str) {
self.command(json!(["loadfile", url, "append-play"]));
}
pub fn play_index(&self, index: usize) {
self.command(json!(["playlist-play-index", index]));
self.command(json!(["set_property", "pause", false]));
}
pub fn toggle_pause(&self) {
self.command(json!(["cycle", "pause"]));
}
pub fn next(&self) {
self.command(json!(["playlist-next"]));
}
pub fn prev(&self) {
self.command(json!(["playlist-prev"]));
}
pub fn seek(&self, seconds: f64) {
self.command(json!(["seek", seconds, "relative"]));
}
}
impl Drop for Player {
fn drop(&mut self) {
self.command(json!(["quit"]));
if let Ok(mut child) = self.child.lock() {
std::thread::sleep(Duration::from_millis(50));
let _ = child.kill();
let _ = child.wait();
}
let _ = std::fs::remove_file(&self.socket);
}
}
fn parse_event(line: &str) -> Option<PlayerEvent> {
let v: Value = serde_json::from_str(line).ok()?;
if v.get("event")?.as_str()? != "property-change" {
return None;
}
let data = v.get("data");
match v.get("name")?.as_str()? {
"time-pos" => Some(PlayerEvent::Position(data.and_then(Value::as_f64).unwrap_or(0.0))),
"duration" => Some(PlayerEvent::Duration(data.and_then(Value::as_f64).unwrap_or(0.0))),
"pause" => Some(PlayerEvent::Paused(data.and_then(Value::as_bool).unwrap_or(false))),
"playlist-pos" => Some(PlayerEvent::Track(
data.and_then(Value::as_i64).filter(|&i| i >= 0).map(|i| i as usize),
)),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_property_changes() {
let ev = parse_event(r#"{"event":"property-change","id":4,"name":"playlist-pos","data":2}"#);
assert!(matches!(ev, Some(PlayerEvent::Track(Some(2)))));
let ev = parse_event(r#"{"event":"property-change","id":4,"name":"playlist-pos","data":-1}"#);
assert!(matches!(ev, Some(PlayerEvent::Track(None))));
let ev = parse_event(r#"{"event":"property-change","id":1,"name":"time-pos"}"#);
assert!(matches!(ev, Some(PlayerEvent::Position(p)) if p == 0.0));
assert!(parse_event(r#"{"request_id":0,"error":"success"}"#).is_none());
}
}
+484
View File
@@ -0,0 +1,484 @@
//! Minimal OpenSubsonic client covering what the browser and player need.
use std::hash::{BuildHasher, RandomState};
use std::time::{SystemTime, UNIX_EPOCH};
use anyhow::{Context, Result, anyhow, bail};
use serde::Deserialize;
use serde::de::{DeserializeOwned, Deserializer};
const API_VERSION: &str = "1.16.1";
const CLIENT_NAME: &str = "remus";
#[derive(Clone)]
pub struct Client {
http: reqwest::Client,
base: String,
user: String,
salt: String,
token: String,
}
impl Client {
pub fn new(base: &str, user: &str, salt: &str, token: &str) -> Self {
let http = reqwest::Client::builder()
.user_agent(concat!("remus/", env!("CARGO_PKG_VERSION")))
.timeout(std::time::Duration::from_secs(30))
.build()
.expect("http client");
Client {
http,
base: normalize_base(base),
user: user.to_string(),
salt: salt.to_string(),
token: token.to_string(),
}
}
/// Derives a token from the password so the password itself is never stored.
/// The token is still password-equivalent for this server.
pub fn from_password(base: &str, user: &str, password: &str) -> Self {
let salt = random_salt();
let token = format!("{:x}", md5::compute(format!("{password}{salt}")));
Client::new(base, user, &salt, &token)
}
pub fn base(&self) -> &str {
&self.base
}
pub fn user(&self) -> &str {
&self.user
}
pub fn salt(&self) -> &str {
&self.salt
}
pub fn token(&self) -> &str {
&self.token
}
fn endpoint_url(&self, endpoint: &str, params: &[(&str, String)]) -> Result<reqwest::Url> {
let mut all: Vec<(&str, String)> = vec![
("u", self.user.clone()),
("t", self.token.clone()),
("s", self.salt.clone()),
("v", API_VERSION.to_string()),
("c", CLIENT_NAME.to_string()),
("f", "json".to_string()),
];
all.extend(params.iter().cloned());
reqwest::Url::parse_with_params(&format!("{}/rest/{endpoint}", self.base), &all)
.with_context(|| format!("invalid server url {}", self.base))
}
async fn call<T: DeserializeOwned>(&self, endpoint: &str, params: &[(&str, String)]) -> Result<T> {
let url = self.endpoint_url(endpoint, params)?;
let resp = self
.http
.get(url)
.send()
.await
.map_err(redact)
.with_context(|| format!("{endpoint} request failed"))?;
let status = resp.status();
if !status.is_success() {
bail!("{endpoint}: server returned {status}");
}
let mut body: serde_json::Value = resp
.json()
.await
.map_err(redact)
.with_context(|| format!("{endpoint}: invalid json"))?;
let inner = body
.get_mut("subsonic-response")
.map(serde_json::Value::take)
.ok_or_else(|| anyhow!("{endpoint}: not a subsonic response"))?;
if inner.get("status").and_then(|s| s.as_str()) != Some("ok") {
let msg = inner
.pointer("/error/message")
.and_then(|m| m.as_str())
.unwrap_or("unknown error");
bail!("{msg}");
}
serde_json::from_value(inner).with_context(|| format!("{endpoint}: unexpected response shape"))
}
pub async fn ping(&self) -> Result<()> {
let _: serde_json::Value = self.call("ping", &[]).await?;
Ok(())
}
/// `kind` is a getAlbumList2 type: newest, random, alphabeticalByName, frequent, recent...
pub async fn album_list(&self, kind: &str, size: u32, offset: u32) -> Result<Vec<Album>> {
#[derive(Deserialize)]
struct R {
#[serde(rename = "albumList2", default)]
list: AlbumList,
}
#[derive(Deserialize, Default)]
struct AlbumList {
#[serde(default)]
album: Vec<Album>,
}
let r: R = self
.call(
"getAlbumList2",
&[
("type", kind.into()),
("size", size.to_string()),
("offset", offset.to_string()),
],
)
.await?;
Ok(r.list.album)
}
pub async fn artists(&self) -> Result<Vec<Artist>> {
#[derive(Deserialize)]
struct R {
#[serde(default)]
artists: Indexes,
}
#[derive(Deserialize, Default)]
struct Indexes {
#[serde(default)]
index: Vec<Index>,
}
#[derive(Deserialize)]
struct Index {
#[serde(default)]
artist: Vec<Artist>,
}
let r: R = self.call("getArtists", &[]).await?;
Ok(r.artists.index.into_iter().flat_map(|i| i.artist).collect())
}
pub async fn artist(&self, id: &str) -> Result<ArtistDetail> {
#[derive(Deserialize)]
struct R {
artist: ArtistDetail,
}
let r: R = self.call("getArtist", &[("id", id.into())]).await?;
Ok(r.artist)
}
pub async fn album(&self, id: &str) -> Result<AlbumDetail> {
#[derive(Deserialize)]
struct R {
album: AlbumDetail,
}
let r: R = self.call("getAlbum", &[("id", id.into())]).await?;
Ok(r.album)
}
pub async fn playlists(&self) -> Result<Vec<Playlist>> {
#[derive(Deserialize)]
struct R {
#[serde(default)]
playlists: Lists,
}
#[derive(Deserialize, Default)]
struct Lists {
#[serde(default)]
playlist: Vec<Playlist>,
}
let r: R = self.call("getPlaylists", &[]).await?;
Ok(r.playlists.playlist)
}
pub async fn playlist(&self, id: &str) -> Result<PlaylistDetail> {
#[derive(Deserialize)]
struct R {
playlist: PlaylistDetail,
}
let r: R = self.call("getPlaylist", &[("id", id.into())]).await?;
Ok(r.playlist)
}
pub async fn search(&self, query: &str) -> Result<SearchResult> {
#[derive(Deserialize)]
struct R {
#[serde(rename = "searchResult3", default)]
result: SearchResult,
}
let r: R = self
.call(
"search3",
&[
("query", query.into()),
("artistCount", "20".into()),
("albumCount", "40".into()),
("songCount", "80".into()),
],
)
.await?;
Ok(r.result)
}
pub async fn scrobble(&self, id: &str, submission: bool) -> Result<()> {
let _: serde_json::Value = self
.call("scrobble", &[("id", id.into()), ("submission", submission.to_string())])
.await?;
Ok(())
}
pub async fn cover_art(&self, id: &str, size: u32) -> Result<Vec<u8>> {
let url = self.endpoint_url("getCoverArt", &[("id", id.into()), ("size", size.to_string())])?;
let resp = self.http.get(url).send().await.map_err(redact)?;
let status = resp.status();
if !status.is_success() {
bail!("getCoverArt: server returned {status}");
}
let is_json = resp
.headers()
.get(reqwest::header::CONTENT_TYPE)
.and_then(|v| v.to_str().ok())
.is_some_and(|v| v.contains("json") || v.contains("xml"));
if is_json {
bail!("getCoverArt: no image for {id}");
}
Ok(resp.bytes().await.map_err(redact)?.to_vec())
}
pub fn stream_url(&self, id: &str) -> String {
self.endpoint_url("stream", &[("id", id.into())])
.map(|u| u.to_string())
.unwrap_or_default()
}
}
/// Request URLs carry the auth token, so they must never reach an error
/// message: those end up on screen and in the logs.
fn redact(e: reqwest::Error) -> reqwest::Error {
e.without_url()
}
fn normalize_base(base: &str) -> String {
let base = base.trim().trim_end_matches('/');
let base = base.strip_suffix("/rest").unwrap_or(base);
if base.starts_with("http://") || base.starts_with("https://") {
base.to_string()
} else {
format!("https://{base}")
}
}
fn random_salt() -> String {
let nanos = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let a = RandomState::new().hash_one(nanos);
let b = RandomState::new().hash_one(a ^ u64::from(std::process::id()));
format!("{a:016x}{b:016x}")
}
/// Older servers send ids as numbers, OpenSubsonic as strings.
fn de_id<'de, D: Deserializer<'de>>(d: D) -> Result<String, D::Error> {
Ok(match serde_json::Value::deserialize(d)? {
serde_json::Value::String(s) => s,
serde_json::Value::Number(n) => n.to_string(),
other => other.to_string(),
})
}
fn de_opt_id<'de, D: Deserializer<'de>>(d: D) -> Result<Option<String>, D::Error> {
Ok(match Option::<serde_json::Value>::deserialize(d)? {
Some(serde_json::Value::String(s)) if !s.is_empty() => Some(s),
Some(serde_json::Value::Number(n)) => Some(n.to_string()),
_ => None,
})
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Album {
#[serde(deserialize_with = "de_id")]
pub id: String,
#[serde(default)]
pub name: String,
#[serde(default)]
pub artist: Option<String>,
#[serde(default, deserialize_with = "de_opt_id")]
pub cover_art: Option<String>,
#[serde(default)]
pub year: Option<i32>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Artist {
#[serde(deserialize_with = "de_id")]
pub id: String,
#[serde(default)]
pub name: String,
#[serde(default)]
pub album_count: Option<u32>,
#[serde(default, deserialize_with = "de_opt_id")]
pub cover_art: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ArtistDetail {
#[serde(default)]
pub name: String,
#[serde(default)]
pub album: Vec<Album>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AlbumDetail {
#[serde(default)]
pub name: String,
#[serde(default)]
pub artist: Option<String>,
#[serde(default, deserialize_with = "de_opt_id")]
pub cover_art: Option<String>,
#[serde(default)]
pub year: Option<i32>,
#[serde(default)]
pub duration: Option<u32>,
#[serde(default)]
pub song: Vec<Song>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Song {
#[serde(deserialize_with = "de_id")]
pub id: String,
#[serde(default)]
pub title: String,
#[serde(default)]
pub artist: Option<String>,
#[serde(default)]
pub album: Option<String>,
#[serde(default, deserialize_with = "de_opt_id")]
pub cover_art: Option<String>,
#[serde(default)]
pub duration: Option<u32>,
#[serde(default)]
pub track: Option<u32>,
#[serde(default)]
pub disc_number: Option<u32>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Playlist {
#[serde(deserialize_with = "de_id")]
pub id: String,
#[serde(default)]
pub name: String,
#[serde(default)]
pub song_count: Option<u32>,
#[serde(default, deserialize_with = "de_opt_id")]
pub cover_art: Option<String>,
#[serde(default)]
pub owner: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PlaylistDetail {
#[serde(default)]
pub name: String,
#[serde(default, deserialize_with = "de_opt_id")]
pub cover_art: Option<String>,
#[serde(default)]
pub duration: Option<u32>,
#[serde(default)]
pub entry: Vec<Song>,
}
#[derive(Debug, Clone, Default, Deserialize)]
pub struct SearchResult {
#[serde(default)]
pub artist: Vec<Artist>,
#[serde(default)]
pub album: Vec<Album>,
#[serde(default)]
pub song: Vec<Song>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn base_url_is_normalized() {
assert_eq!(normalize_base("music.example.com/"), "https://music.example.com");
assert_eq!(normalize_base("http://nas:4533/rest"), "http://nas:4533");
}
#[test]
fn numeric_ids_are_accepted() {
let a: Album = serde_json::from_str(r#"{"id": 42, "name": "X", "coverArt": 7}"#).unwrap();
assert_eq!(a.id, "42");
assert_eq!(a.cover_art.as_deref(), Some("7"));
}
/// Exercises every endpoint against a real server:
/// REMUS_TEST_URL=... REMUS_TEST_USER=... REMUS_TEST_PASS=... cargo test -- --ignored
#[tokio::test]
#[ignore]
async fn live_server() {
let var = |k| std::env::var(k).unwrap_or_else(|_| panic!("{k} not set"));
let c = Client::from_password(&var("REMUS_TEST_URL"), &var("REMUS_TEST_USER"), &var("REMUS_TEST_PASS"));
c.ping().await.unwrap();
let albums = c.album_list("newest", 10, 0).await.unwrap();
assert!(!albums.is_empty(), "no albums");
let album = c.album(&albums[0].id).await.unwrap();
assert!(!album.song.is_empty(), "album has no songs");
println!(
"album: {} by {:?}, {} songs",
album.name,
album.artist,
album.song.len()
);
let cover = album.cover_art.as_deref().expect("album has no cover id");
let bytes = c.cover_art(cover, 256).await.unwrap();
let img = image::load_from_memory(&bytes).unwrap();
println!("cover: {}x{}", img.width(), img.height());
let artists = c.artists().await.unwrap();
assert!(!artists.is_empty(), "no artists");
let artist = c.artist(&artists[0].id).await.unwrap();
println!("artist: {} with {} albums", artist.name, artist.album.len());
let playlists = c.playlists().await.unwrap();
if let Some(p) = playlists.first() {
let p = c.playlist(&p.id).await.unwrap();
println!("playlist: {} with {} entries", p.name, p.entry.len());
}
let found = c.search(&album.name).await.unwrap();
assert!(!found.album.is_empty(), "search found nothing for {}", album.name);
let url = c.stream_url(&album.song[0].id);
let resp = reqwest::get(&url).await.unwrap();
assert!(resp.status().is_success(), "stream returned {}", resp.status());
println!("stream content-type: {:?}", resp.headers().get("content-type"));
}
#[tokio::test]
async fn errors_never_contain_the_token() {
// Port 1 on loopback refuses the connection, so the request fails.
let c = Client::new("http://127.0.0.1:1", "u", "somesalt", "secrettoken");
let err = format!("{:#}", c.ping().await.unwrap_err());
assert!(!err.contains("secrettoken"), "token leaked: {err}");
assert!(!err.contains("somesalt"), "salt leaked: {err}");
let err = format!("{:#}", c.cover_art("al-1", 256).await.unwrap_err());
assert!(!err.contains("secrettoken"), "token leaked: {err}");
}
#[test]
fn token_is_md5_of_password_and_salt() {
let c = Client::from_password("http://x", "u", "sesame");
let expected = format!("{:x}", md5::compute(format!("sesame{}", c.salt())));
assert_eq!(c.token(), expected);
}
}
+1102
View File
File diff suppressed because it is too large Load Diff