Compare commits

...
Author SHA1 Message Date
sanapachandClaude Opus 5.5 4f17feef71 Point frid deps at the fork branch
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-20 15:12:29 +02:00
sanapachandClaude Opus 5.5 c1cd689ea0 Test episode resume positions and rollback cleanup on PostgreSQL
The ignored device-sync PostgreSQL test now also covers a handoff and a
remote Next onto an episode with an unknown position (the relayed
progress register supplies 1200 s and its generation), and checks that
0.12's operation types fail on a relayed podcast operation and read the
log again after the documented cleanup statement, which the m_0055
backwards operation now shares.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 19:26:40 +02:00
sanapachandClaude Opus 5.5 a04a7460e6 Note the review fixes in the changelog and docs
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 19:22:26 +02:00
sanapachandClaude Opus 5.5 3af0e8ccc9 Keep a rollback to 0.12 safe for sync and the typed queue
Release 0.12 fails a whole sync batch on a podcast operation kind, so
rolling back is only safe after the relayed podcast operations are
removed: document the step in docs/administration.md and run it in the
m_0055 backwards operation.

The typed queue now records the current track id and queue position
written with it, next to the legacy ids. A 0.12 release that only moved
to another track in the same queue no longer leaves a stale typed
position that the next upgrade would restore. Jam placeholders are never
stored in a user's own typed queue.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 19:22:19 +02:00
sanapachandClaude Opus 5.5 6f3ed4b7ee Check Jam participant commands against the host queue
The server checked a participant's queue_remove/queue_clear against the
host state of the last report, but the host browser runs its pending
commands in one batch: after a move, a checked index can name a private
item. Participant commands are now stamped `jam_participant`, and the
host browser refuses to remove, clear, add or bring back its private
items for them, judged on the queue it is about to change.

A guest that stops controlling a Jam drops the host's private
placeholders from its own queue, so they are not saved or relayed as
the guest's queue.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 19:21:51 +02:00
sanapachandClaude Opus 5.5 d1be583d1e Resume unknown episode positions from progress, not 0
The web player only knows a podcast episode's position from a handoff or
a seek. When Next, auto-advance, a click or a play command makes an
episode current, it now reports `position_unknown` instead of 0, and the
server takes the resume position (and the register generation) from the
relayed progress register before it hands the state to another device.
Remote Next/Prev/play commands to a device do the same.

Next with repeat all or shuffle wraps past a trailing unplayable item
instead of stopping on it. Prev leaves an unplayable item instead of
"restarting" it, and seeking such an item moves its kept position.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 19:21:25 +02:00
sanapachandClaude Opus 5.5 ab7202fc73 Note the podcast queue fixes in the changelog
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 18:35:49 +02:00
sanapachandClaude Opus 5.5 19139ea830 Undo metadata deletions archived before the typed queue column
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 18:35:49 +02:00
sanapachandClaude Opus 5.5 a9736e5914 Keep Jam guests from removing or timing the host's private items
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 18:35:49 +02:00
sanapachandClaude Opus 5.5 4d0b352258 Keep the episode position and skip unplayable items safely in the player
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 18:35:49 +02:00
sanapachandClaude Opus 5.5 c14ab8dfea Document podcast queue support and release 0.13.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 16:58:32 +02:00
sanapachandClaude Opus 5.5 b558cf381e Relay device-sync v4 and keep podcast queue items
Use the shared music_dht::device_sync types instead of private copies
(byte-identical for v3 content, checked against the 0.12.x types and a
golden fixture) and announce protocol 4, because every v4 element is
kept:

- podcast operations stay in the operation log and are relayed only to
  peers that reported v4; their registers and the podcast snapshot
  sections are merged with the shared rules into an opaque relay table
  and returned in this server's snapshots (m_0055);
- the browser bridge carries PlaybackTrack.source: items that are not
  library tracks keep the verbatim wire item, so podcast episodes and
  Jam placeholders survive the round trip; the player labels and skips
  them instead of dropping them;
- the typed queue is persisted in queue_items_json next to queue_json,
  which is still written for rollback (m_0054).

Peer versions come from self-reports (profile_protocol_version); relayed
profiles only raise them and DeviceProfileSet no longer stores this
server's constant. Invites carry the inviter's version and a
DeviceProfileSet announces v4 once. Handoffs of a podcast queue to a
device below v4 are refused with an update message, and its playback
commands are ignored while the queue has podcast items. Jam guests see
podcast items as private placeholders, which are mapped back on their
commands.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 16:58:29 +02:00
sanapachandClaude Opus 5.5 75c67026ac Update music-dht to 0.6.0
The podcast contract and device-sync protocol v4 live in music-dht 0.6.
Cargo.lock currently resolves it from a local patch of the frid branch
podcasts/contract and must be regenerated against the published crate.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-19 16:58:21 +02:00
25 changed files with 4979 additions and 674 deletions

No files matched your search

+27
View File
@@ -1,5 +1,32 @@
# Changelog
## v0.13.0 — 2026-11-19
- Use the shared `music-dht` 0.6 device-sync types and announce device-sync
protocol 4. Podcast operations and snapshot sections from other devices are
kept and relayed; devices below protocol 4 never receive them.
- Keep podcast episodes and other non-library queue items through the web
player, with their explicit source. The player labels and skips them; the
typed queue is stored next to `queue_json` (migrations `m_0054`, `m_0055`).
A handoff through the web player keeps the position of the current episode.
- Refuse a playback transfer of a queue with podcast episodes to a device that
needs an update, and ignore its playback commands while the queue has them.
- Store the protocol version each device reports itself instead of this
server's version; invites carry the inviter's version.
- An episode that the web player selects without knowing its position (Next,
auto-advance, a click) resumes from its synchronized progress on the next
device instead of restarting at 0. Repeat all and shuffle continue past
episodes; Prev and seeking work on them.
- Jam guests see podcast episodes of the host as private items, without their
duration, and cannot add, remove or clear them; the host browser enforces
this on its own queue. Guests do not keep the placeholders after the Jam.
- Metadata Repair can still undo deletions recorded before the typed queue
column was added.
- Rolling back to 0.12 requires removing the relayed podcast operations first;
see "Rolling back to 0.12" in `docs/administration.md`. After a rollback, the
typed queue is used again only if 0.12 left the queue and its current track
unchanged.
## v0.10.6 — 2026-09-02
- Recover federation automatically after sleep, prolonged idle, or a degraded rendezvous transport.
Generated
+4 -6
View File
@@ -1843,8 +1843,7 @@ dependencies = [
[[package]]
name = "federation-net"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "01e5c2e6e5af020dc202d4924125ef57719aa21f8d2567e2d943914386bc8980"
source = "git+https://gt.hexor.cy/Sanapach/frid.git?branch=podcasts%2Fcontract#65d6ca2f14a1324dc129b90694da83ceb55c60dc"
dependencies = [
"blake3",
"data-encoding",
@@ -1988,7 +1987,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
[[package]]
name = "furumusic"
version = "0.12.4"
version = "0.13.0"
dependencies = [
"anyhow",
"async-stream",
@@ -3900,9 +3899,8 @@ dependencies = [
[[package]]
name = "music-dht"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4c3f75d49d3a742a6777a1c4cc53f397399dfc9ddb70034c57aeb44d75d2ee4f"
version = "0.6.0"
source = "git+https://gt.hexor.cy/Sanapach/frid.git?branch=podcasts%2Fcontract#65d6ca2f14a1324dc129b90694da83ceb55c60dc"
dependencies = [
"async-trait",
"blake3",
+6 -2
View File
@@ -1,6 +1,6 @@
[package]
name = "furumusic"
version = "0.12.4"
version = "0.13.0"
edition = "2024"
description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
@@ -56,4 +56,8 @@ uuid = "1"
librqbit = { version = "8.1.1", features = ["disable-upload"] }
# P2P federation: publishes the library into a shared DHT and serves audio /
# catalogs to furumi peers (TUI clients) over the frid stack.
music-dht = "0.5.0"
music-dht = "0.6.0"
[patch.crates-io]
# Unpublished frid (MR-F1); remove once music-dht 0.6.0 is on crates.io.
music-dht = { git = "https://gt.hexor.cy/Sanapach/frid.git", branch = "podcasts/contract" }
+25
View File
@@ -71,6 +71,31 @@ Trusted-device pairing is separate from public catalog discovery. It connects
a user's own Furumi players so likes, playlists, playback state, and control can
move between approved devices.
Queues synchronized from other Furumi players can contain podcast episodes. The
web player keeps them in the queue, in order and with their position, and shows
them as **Podcast · not playable in the web player yet**; local playback skips
them. A device that does not support podcasts yet (device-sync protocol below
4, for example an older terminal player) cannot receive such a queue: selecting
it as the playback device shows that it needs an update, and the episodes stay
in the queue. Jam guests see podcast episodes of the host only as private items.
### Rolling back to 0.12
Release 0.13 relays podcast synchronization operations from other Furumi
players. Release 0.12 cannot read them: device synchronization would fail for
every device that has not received them yet. Before you start a 0.12 release
on a database that 0.13 used, stop the server and remove those operations:
```sql
DELETE FROM furumusic__fed_sync_ops WHERE kind LIKE 'podcast\_%';
```
Devices that support podcasts keep their own podcast state. The relay table
`furumusic__fed_podcast_relay` and the typed queue column can stay: 0.12
ignores them, and after the next upgrade 0.13 returns the relayed podcast state
in its snapshots again and uses the typed queue only while it matches the
queue, current track and position that 0.12 saved.
## Admin statistics
The only admin interface is `/admin/v2`, also reachable from `/admin/`.
+45
View File
@@ -35,6 +35,51 @@ source code, templates or prompts reuse the dependency layer when its recipe and
toolchain are unchanged. Both dependency and application builds use `--locked`.
Update the pinned build tools in `Dockerfile`; changing them rebuilds the cache.
## Connected devices and podcast queue items
Trusted-device sync uses the shared `music_dht::device_sync` types (no local
copies) and announces protocol version 4. The web player has no podcast
features yet, but it keeps every v4 element it receives:
- podcast operations stay in the operation log and are relayed to v4 devices
only; their registers and the podcast snapshot sections are merged with the
shared `music_dht::podcast` rules into `furumusic__fed_podcast_relay`
(opaque contract JSON) and returned in this server's snapshots;
- queue items that are not library tracks become external browser items
(`source` plus the verbatim `wire_track`), so podcast episodes and Jam
placeholders survive peer → server → browser → server → peer unchanged;
- `furumusic__playback_state.queue_items_json` stores the typed queue next to
`queue_json`. `queue_json` (library ids) is still written for rollback; the
typed value is used only while the legacy columns it recorded
(`queue_json`, `current_track_id`, `queue_position`) match the row. Jam
placeholders are never stored in a user's own queue.
- a browser that selects a podcast episode it cannot play does not know the
episode's position. It reports `position_unknown`, and the server sends the
resume position of the relayed progress register instead of 0. Jam
participant commands carry `jam_participant`; the host browser checks them
against its own queue.
Rolling back to 0.12 needs the podcast operations removed from the operation
log first; see "Rolling back to 0.12" in `administration.md`.
Everything sent to a device is gated by the version that device reported itself
(`profile_protocol_version`; relayed profiles only raise it). See the podcast
contract (`PODCASTS.md`) and `PLAYBACK_PROTOCOL.md` in the Frid repository.
```bash
cargo test devices:: queue_items podcast_relay queue_persistence
node --test tests/player_queue_sources.test.cjs
# Migrated disposable PostgreSQL (start the server against it once):
FURU_DEVICE_SYNC_TEST_DATABASE_URL=postgresql://... \
cargo test devices::postgres_tests -- --ignored
FURU_METADATA_FIX_TEST_DATABASE_URL=postgresql://... \
cargo test undo_accepts_playback_archives_written_before_the_typed_queue -- --ignored
```
`wire_compat_tests` compares the shared types with the private copies of
0.12.x byte for byte; `fixtures/v3_hello.golden.json` is the v3 shape. Rewrite
it only for a deliberate change, with `FURUMUSIC_BLESS_GOLDEN=1`.
## Contributing
Bug reports, design discussions, and patches are welcome. Before submitting a
+75 -6
View File
@@ -1438,18 +1438,28 @@ async fn delete_entities(
}
}
// Playback queues contain local IDs rather than foreign keys.
let states: Vec<(i64, Option<i64>, String)> = sqlx::query_as(
"SELECT id,current_track_id,queue_json FROM furumusic__playback_state FOR UPDATE",
// (id, current_track_id, queue_json, queue_items_json, queue_position)
type QueueRow = (i64, Option<i64>, String, Option<serde_json::Value>, i32);
let states: Vec<QueueRow> = sqlx::query_as(
"SELECT id,current_track_id,queue_json,queue_items_json,queue_position FROM furumusic__playback_state FOR UPDATE",
)
.fetch_all(&mut *conn)
.await?;
for (id, current, queue_json) in states {
for (id, current, queue_json, queue_items_json, queue_position) in states {
let mut queue: Vec<i64> = serde_json::from_str(&queue_json).unwrap_or_default();
if !current.is_some_and(|id| deleted.tracks.contains(&id))
&& !queue.iter().any(|id| deleted.tracks.contains(id))
{
continue;
}
let mut typed = crate::player::queue_items::StoredQueue::from_columns(
queue_items_json.as_ref(),
&crate::player::queue_items::LegacyColumns {
queue: queue.clone(),
current_track_id: current,
queue_position,
},
);
let before: String = sqlx::query_scalar(
"SELECT to_jsonb(t)::text FROM furumusic__playback_state t WHERE id=$1",
)
@@ -1461,8 +1471,19 @@ async fn delete_entities(
let position = current
.and_then(|id| queue.iter().position(|x| *x == id))
.unwrap_or(0) as i32;
let after: String = sqlx::query_scalar("UPDATE furumusic__playback_state SET current_track_id=$2,queue_json=$3,queue_position=$4,position_ms=CASE WHEN current_track_id IS DISTINCT FROM $2 THEN 0 ELSE position_ms END WHERE id=$1 RETURNING to_jsonb(furumusic__playback_state)::text")
.bind(id).bind(current).bind(serde_json::to_string(&queue)?).bind(position).fetch_one(&mut *conn).await?;
if let Some(typed) = &mut typed {
typed.retain_library(
|id| !deleted.tracks.contains(&id),
crate::player::queue_items::LegacyColumns {
queue: queue.clone(),
current_track_id: current,
queue_position: position,
},
);
}
let queue_items_json = typed.map(serde_json::to_value).transpose()?;
let after: String = sqlx::query_scalar("UPDATE furumusic__playback_state SET current_track_id=$2,queue_json=$3,queue_position=$4,queue_items_json=$5,position_ms=CASE WHEN current_track_id IS DISTINCT FROM $2 THEN 0 ELSE position_ms END WHERE id=$1 RETURNING to_jsonb(furumusic__playback_state)::text")
.bind(id).bind(current).bind(serde_json::to_string(&queue)?).bind(position).bind(queue_items_json).fetch_one(&mut *conn).await?;
archived.push(ArchivedRows {
table: "furumusic__playback_state".into(),
rows: serde_json::json!([serde_json::from_str::<serde_json::Value>(&before)?]),
@@ -1502,6 +1523,7 @@ async fn restore_deleted(conn: &mut PgConnection, archived: &[ArchivedRows]) ->
&[
"current_track_id",
"queue_json",
"queue_items_json",
"queue_position",
"position_ms",
]
@@ -1515,7 +1537,9 @@ async fn restore_deleted(conn: &mut PgConnection, archived: &[ArchivedRows]) ->
})
.collect::<Vec<_>>()
.join(",");
let affected = sqlx::query(&format!("UPDATE {table} t SET {assignments} FROM jsonb_array_elements($1::jsonb) WITH ORDINALITY b(value,n) JOIN jsonb_array_elements($2::jsonb) WITH ORDINALITY a(value,n) USING(n) WHERE to_jsonb(t)=a.value"))
// Archives written before m_0054 have no `queue_items_json` key;
// compare them without the column added since.
let affected = sqlx::query(&format!("UPDATE {table} t SET {assignments} FROM jsonb_array_elements($1::jsonb) WITH ORDINALITY b(value,n) JOIN jsonb_array_elements($2::jsonb) WITH ORDINALITY a(value,n) USING(n) WHERE (CASE WHEN a.value ? 'queue_items_json' THEN to_jsonb(t) ELSE to_jsonb(t) - 'queue_items_json' END)=a.value"))
.bind(entry.rows.to_string()).bind(after.to_string()).execute(&mut *conn).await?.rows_affected();
anyhow::ensure!(
affected as usize == after.as_array().map_or(0, Vec::len),
@@ -1804,6 +1828,51 @@ pub(super) async fn undo(
mod tests {
use super::*;
#[tokio::test]
#[ignore = "requires a migrated disposable database in FURU_METADATA_FIX_TEST_DATABASE_URL"]
async fn undo_accepts_playback_archives_written_before_the_typed_queue() {
let pool =
sqlx::PgPool::connect(&std::env::var("FURU_METADATA_FIX_TEST_DATABASE_URL").unwrap())
.await
.unwrap();
let mut tx = pool.begin().await.unwrap();
let user_id = 9_000_000_000 + i64::from(std::process::id());
// State after the deletion, read back like an archive written by 0.12
// (`to_jsonb` of the row before m_0054 added `queue_items_json`).
let after: serde_json::Value = sqlx::query_scalar(
"INSERT INTO furumusic__playback_state (user_id,current_track_id,position_ms,queue_json,queue_position,shuffle,repeat_mode,volume,updated_at) VALUES ($1,NULL,0,'[]',0,false,'off',0.7,'now') RETURNING to_jsonb(furumusic__playback_state) - 'queue_items_json'",
)
.bind(user_id)
.fetch_one(&mut *tx)
.await
.unwrap();
let mut before = after.clone();
before["queue_json"] = serde_json::json!("[123456789]");
before["position_ms"] = serde_json::json!(5000);
let archive = ArchivedRows {
table: "furumusic__playback_state".into(),
rows: serde_json::json!([before]),
after: Some(serde_json::json!([after])),
};
restore_deleted(&mut tx, std::slice::from_ref(&archive))
.await
.unwrap();
let (queue_json, position_ms, typed): (String, i32, Option<serde_json::Value>) =
sqlx::query_as(
"SELECT queue_json,position_ms,queue_items_json FROM furumusic__playback_state WHERE user_id=$1",
)
.bind(user_id)
.fetch_one(&mut *tx)
.await
.unwrap();
assert_eq!(queue_json, "[123456789]");
assert_eq!(position_ms, 5000);
assert_eq!(typed, None);
// A row changed since the deletion is still refused.
assert!(restore_deleted(&mut tx, &[archive]).await.is_err());
tx.rollback().await.unwrap();
}
fn snapshot() -> Snapshot {
Snapshot {
artists: vec![ArtistState {
+569 -640
View File
File diff suppressed because it is too large. Load diff
@@ -0,0 +1 @@
{"type":"hello","group_id":"grp_1","profile":{"device_id":"tui_a","name":"TUI","client_version":"0.3.4","protocol_version":3,"endpoint_id":"e","endpoint_ticket":"t","revoked":false,"revoke_cutoff_seq":null,"updated_at_ms":5},"devices":[{"device_id":"tui_a","name":"TUI","client_version":"0.3.4","protocol_version":3,"endpoint_id":"e","endpoint_ticket":"t","revoked":false,"revoke_cutoff_seq":null,"updated_at_ms":5},{"device_id":"web_b","name":"TUI","client_version":"0.3.4","protocol_version":3,"endpoint_id":"e","endpoint_ticket":"t","revoked":false,"revoke_cutoff_seq":null,"updated_at_ms":5}],"vector":{"tui_a":12,"web_b":4},"ops":[{"op_id":"tui_a:1","origin_device_id":"tui_a","seq":1,"hlc_ms":1700000000001,"payload":{"kind":"track_like_set","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","liked":true,"fed":{"item_id":"item","owner":"owner","title":"Song","artist_names":["A"],"featured_artist_names":[],"year":2001,"duration_seconds":180,"content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","release_title":"Album","track_number":1,"disc_number":1}}},{"op_id":"tui_a:2","origin_device_id":"tui_a","seq":2,"hlc_ms":1700000000002,"payload":{"kind":"playlist_created","playlist_id":"pl","title":"Mix"}},{"op_id":"tui_a:3","origin_device_id":"tui_a","seq":3,"hlc_ms":1700000000003,"payload":{"kind":"playlist_renamed","playlist_id":"pl","title":"Mix 2"}},{"op_id":"tui_a:4","origin_device_id":"tui_a","seq":4,"hlc_ms":1700000000004,"payload":{"kind":"playlist_track_added","playlist_id":"pl","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","position":0,"fed":null}},{"op_id":"tui_a:5","origin_device_id":"tui_a","seq":5,"hlc_ms":1700000000005,"payload":{"kind":"playlist_track_removed","playlist_id":"pl","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111"}},{"op_id":"tui_a:6","origin_device_id":"tui_a","seq":6,"hlc_ms":1700000000006,"payload":{"kind":"playlist_deleted","playlist_id":"pl"}},{"op_id":"tui_a:7","origin_device_id":"tui_a","seq":7,"hlc_ms":1700000000007,"payload":{"kind":"device_profile_set","name":"TUI","client_version":"0.3.4","endpoint_ticket":"t","endpoint_id":"e"}},{"op_id":"tui_a:8","origin_device_id":"tui_a","seq":8,"hlc_ms":1700000000008,"payload":{"kind":"device_trusted","target_device_id":"web_b"}},{"op_id":"tui_a:9","origin_device_id":"tui_a","seq":9,"hlc_ms":1700000000009,"payload":{"kind":"device_revoked","target_device_id":"old","target_max_seq_seen":3}},{"op_id":"tui_a:10","origin_device_id":"tui_a","seq":10,"hlc_ms":1700000000010,"payload":{"kind":"playback_command","target_device_id":"web_b","command":{"kind":"set_state","state":{"queue":[{"id":7,"title":"Song","track_number":1,"disc_number":null,"duration_seconds":180.5,"artist_names":["A"],"featured_artist_names":["B"],"release_id":3,"release_title":"Album","release_year":2001,"file_path":"","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","audio_format":"flac","audio_bitrate":900,"audio_sample_rate":44100,"audio_bit_depth":16,"file_size_bytes":12345,"play_count":2,"fed":{"item_id":"item","owner":"owner","title":"Song","artist_names":["A"],"featured_artist_names":[],"year":2001,"duration_seconds":180,"content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","release_title":"Album","track_number":1,"disc_number":1}},{"id":0,"title":"Remote","track_number":null,"disc_number":null,"duration_seconds":0.0,"artist_names":[],"featured_artist_names":[],"release_id":0,"release_title":"","release_year":null,"file_path":"","content_id":null,"audio_format":null,"audio_bitrate":null,"audio_sample_rate":null,"audio_bit_depth":null,"file_size_bytes":null,"play_count":0,"fed":null}],"queue_pos":1,"playing":true,"paused":false,"idle_since_ms":null,"position_secs":42.5,"volume":73,"shuffle":true,"repeat":"all"},"seek":true},"authority":{"version":1,"claim":{"counter":3,"issuer":"tui_a","owner":"tui_a"},"sequence":9}}},{"op_id":"tui_a:11","origin_device_id":"tui_a","seq":11,"hlc_ms":1700000000011,"payload":{"kind":"playback_command","target_device_id":"web_b","command":{"kind":"active_changed","active_device_id":"web_b","active_device_name":"WEB","state":{"queue":[{"id":7,"title":"Song","track_number":1,"disc_number":null,"duration_seconds":180.5,"artist_names":["A"],"featured_artist_names":["B"],"release_id":3,"release_title":"Album","release_year":2001,"file_path":"","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","audio_format":"flac","audio_bitrate":900,"audio_sample_rate":44100,"audio_bit_depth":16,"file_size_bytes":12345,"play_count":2,"fed":{"item_id":"item","owner":"owner","title":"Song","artist_names":["A"],"featured_artist_names":[],"year":2001,"duration_seconds":180,"content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","release_title":"Album","track_number":1,"disc_number":1}},{"id":0,"title":"Remote","trackLine truncated
+575
View File
@@ -0,0 +1,575 @@
//! Version gating and lossless queue bridge (device-sync protocol v4).
use super::*;
use crate::player::queue_items::{self, test_episode};
use music_dht::podcast::{
EpisodeId, FeedUrl, ListenSession, PodcastId, PodcastMeta, ProgressStatus,
};
const CONTENT_ID: &str = "b3:2222222222222222222222222222222222222222222222222222222222222222";
fn podcast_id() -> PodcastId {
PodcastId::from_feed_url(&FeedUrl::parse("https://podcasts.example/feed.xml").unwrap())
}
fn episode_id() -> EpisodeId {
EpisodeId::from_guid(&podcast_id(), "ep-1").unwrap()
}
fn music_track(id: i64) -> PlaybackTrack {
let mut track = PlaybackTrack::private_placeholder();
track.source = None;
track.id = id;
track.title = format!("Song {id}");
track
}
fn state(queue: Vec<PlaybackTrack>) -> PlaybackStateWire {
PlaybackStateWire {
queue,
queue_pos: 0,
playing: true,
paused: false,
idle_since_ms: None,
position_secs: 12.5,
volume: 70,
shuffle: false,
repeat: PlaybackRepeat::Off,
playback_rate: None,
}
}
fn podcast_state() -> PlaybackStateWire {
state(vec![
music_track(1),
PlaybackTrack::podcast_episode(test_episode()),
])
}
/// One payload of every operation kind (music-only playback commands).
fn every_payload(playback: PlaybackStateWire) -> Vec<SyncOpPayload> {
let session = ListenSession {
session_id: "s1".into(),
episode_id: episode_id(),
podcast_id: podcast_id(),
device_id: "tui_a".into(),
started_at_ms: 1,
ended_at_ms: 2,
start_position_ms: 0,
end_position_ms: 1,
listened_ms: 1,
completed: false,
};
let meta: PodcastMeta = serde_json::from_value(serde_json::json!({
"feed_url": "https://podcasts.example/feed.xml", "title": "Cast"
}))
.unwrap();
vec![
SyncOpPayload::TrackLikeSet {
content_id: CONTENT_ID.into(),
liked: true,
fed: None,
},
SyncOpPayload::PlaylistCreated {
playlist_id: "p".into(),
title: "t".into(),
},
SyncOpPayload::PlaylistRenamed {
playlist_id: "p".into(),
title: "t".into(),
},
SyncOpPayload::PlaylistDeleted {
playlist_id: "p".into(),
},
SyncOpPayload::PlaylistTrackAdded {
playlist_id: "p".into(),
content_id: CONTENT_ID.into(),
position: 0,
fed: None,
},
SyncOpPayload::PlaylistTrackRemoved {
playlist_id: "p".into(),
content_id: CONTENT_ID.into(),
},
SyncOpPayload::DeviceProfileSet {
name: "n".into(),
client_version: "v".into(),
endpoint_ticket: "t".into(),
endpoint_id: "e".into(),
protocol_version: Some(4),
},
SyncOpPayload::DeviceTrusted {
target_device_id: "d".into(),
},
SyncOpPayload::DeviceRevoked {
target_device_id: "d".into(),
target_max_seq_seen: 1,
},
SyncOpPayload::PlaybackCommand {
target_device_id: "d".into(),
command: PlaybackCommand::SetState {
state: playback,
seek: false,
},
authority: None,
},
SyncOpPayload::ListenRecorded {
event: ListenEvent {
listen_id: "l".into(),
content_id: CONTENT_ID.into(),
started_at_ms: 1,
listened_ms: 1,
track_duration_ms: None,
ended_reason: ListenEndReason::Finished,
track: ListenTrackMetadata {
title: "t".into(),
artist_names: vec!["a".into()],
featured_artist_names: vec![],
release_title: None,
},
},
},
SyncOpPayload::PodcastSubscriptionSet {
podcast_id: podcast_id(),
subscribed: true,
podcast: meta,
feed_aliases: vec![],
generation: 1,
},
SyncOpPayload::PodcastShareSet {
podcast_id: podcast_id(),
shared: false,
generation: 1,
},
SyncOpPayload::PodcastFeedAliasesAdded {
podcast_id: podcast_id(),
feed_aliases: vec![FeedUrl::parse("https://podcasts.example/new.xml").unwrap()],
},
SyncOpPayload::PodcastProgressSet {
episode_id: episode_id(),
podcast_id: podcast_id(),
position_ms: 1,
status: ProgressStatus::InProgress,
generation: 1,
session_id: "s1".into(),
episode: None,
},
SyncOpPayload::PodcastListenRecorded {
session,
episode: None,
},
]
}
#[test]
fn stored_kind_is_the_wire_tag() {
for payload in every_payload(state(vec![])) {
let value = serde_json::to_value(&payload).unwrap();
assert_eq!(payload_kind(&payload), value["kind"].as_str().unwrap());
}
}
#[test]
fn op_gating_matrix_matches_the_shared_helper() {
// The SQL kind filter must hide exactly what `op_allowed_for_peer`
// rejects (playback commands are content-dependent and checked in Rust).
for version in 1..=PROTOCOL_VERSION {
let hidden = op_kinds_hidden_from(version);
for payload in every_payload(state(vec![music_track(1)])) {
let kind = payload_kind(&payload);
assert_eq!(
hidden.contains(&kind),
!op_allowed_for_peer(&payload, version),
"{kind} for v{version}"
);
}
}
assert!(
op_kinds_hidden_from(3)
.iter()
.all(|kind| kind.starts_with("podcast_"))
);
assert_eq!(op_kinds_hidden_from(3).len(), 5);
assert!(op_kinds_hidden_from(4).is_empty());
}
#[test]
fn playback_gating_matrix() {
let music = state(vec![music_track(1), music_track(2)]);
let podcasts = podcast_state();
let private = state(vec![PlaybackTrack::private_placeholder()]);
for version in 1..=PROTOCOL_VERSION {
let v4 = version >= 4;
// Snapshots and handoffs.
assert!(playback_allowed_for_peer(&music, version));
assert_eq!(playback_allowed_for_peer(&podcasts, version), v4);
assert_eq!(playback_allowed_for_peer(&private, version), v4);
// Commands from the peer.
assert!(playback_command_allowed_from_peer(&music, version));
assert_eq!(playback_command_allowed_from_peer(&podcasts, version), v4);
// Stamped playback command operations.
let command = |state: &PlaybackStateWire| SyncOpPayload::PlaybackCommand {
target_device_id: "d".into(),
command: PlaybackCommand::ActiveChanged {
active_device_id: "d".into(),
active_device_name: "D".into(),
state: state.clone(),
},
authority: None,
};
assert!(op_allowed_for_peer(&command(&music), version));
assert_eq!(op_allowed_for_peer(&command(&podcasts), version), v4);
}
}
#[test]
fn browser_state_gating_sees_podcast_items() {
let with_podcast = serde_json::json!({
"tracks": [
{"id": 5, "title": "Library song"},
queue_items::external_track_json(&PlaybackTrack::podcast_episode(test_episode()), 1, None),
],
"index": 0,
});
let shadow = browser_state_shadow(&with_podcast);
assert!(!playback_command_allowed_from_peer(&shadow, 3));
assert!(playback_command_allowed_from_peer(&shadow, 4));
let music_only = serde_json::json!({"tracks": [{"id": 5}], "index": 0});
assert!(playback_command_allowed_from_peer(
&browser_state_shadow(&music_only),
3
));
}
#[test]
fn relayed_versions_never_downgrade_and_self_reports_replace() {
let profile = |id: &str, version: u16| DeviceProfileWire {
device_id: id.into(),
name: "D".into(),
client_version: "x".into(),
protocol_version: version,
endpoint_id: String::new(),
endpoint_ticket: String::new(),
revoked: false,
revoke_cutoff_seq: None,
updated_at_ms: 0,
};
// A v3 relay lists every device with its own constant.
let relayed = VersionReport::for_listed(&profile("tui_b", 3), Some("tui_a"));
assert_eq!(relayed, VersionReport::Relayed(3));
assert_eq!(relayed.resolve(Some(4)), 4);
assert_eq!(relayed.resolve(None), 3);
assert_eq!(VersionReport::Relayed(4).resolve(Some(3)), 4);
// The sender's own entry is a self-report and may lower the version.
let own = VersionReport::for_listed(&profile("tui_a", 3), Some("tui_a"));
assert_eq!(own, VersionReport::SelfReported(Some(3)));
assert_eq!(own.resolve(Some(4)), 3);
// Profiles without a version (pending pairing, pre-v4 DeviceProfileSet)
// keep the stored value, or the unreported version 1.
assert_eq!(VersionReport::SelfReported(None).resolve(Some(4)), 4);
assert_eq!(VersionReport::SelfReported(None).resolve(None), 1);
}
#[test]
fn podcast_snapshot_sections_are_bounded_per_message() {
let mut snapshot = SyncSnapshot::default();
let progress = music_dht::podcast::ProgressRecord {
episode_id: episode_id(),
podcast_id: podcast_id(),
position_ms: 1,
status: ProgressStatus::InProgress,
generation: 1,
session_id: "s".into(),
hlc_ms: 1,
device_id: "tui_a".into(),
op_id: "tui_a:1".into(),
};
snapshot.podcast_progress = vec![progress; 10];
// Large other parts leave (almost) no budget for podcast sections.
let big_title = "x".repeat(music_dht::device_sync::MAX_SYNC_LINE - 16 * 1024);
let mut message = WireMessage::Hello {
group_id: "g".into(),
profile: DeviceProfileWire {
device_id: "web".into(),
name: big_title,
client_version: String::new(),
protocol_version: PROTOCOL_VERSION,
endpoint_id: String::new(),
endpoint_ticket: String::new(),
revoked: false,
revoke_cutoff_seq: None,
updated_at_ms: 0,
},
devices: vec![],
vector: BTreeMap::new(),
ops: vec![],
snapshot: snapshot.clone(),
playback: None,
};
fit_podcast_snapshot(&mut message);
let WireMessage::Hello {
snapshot: fitted, ..
} = &message
else {
unreachable!()
};
assert!(fitted.podcast_progress.is_empty());
let mut small = WireMessage::SyncResponse {
accepted: true,
error: None,
devices: vec![],
vector: BTreeMap::new(),
ops: vec![],
snapshot,
playback: None,
};
fit_podcast_snapshot(&mut small);
let WireMessage::SyncResponse { snapshot, .. } = &small else {
unreachable!()
};
assert_eq!(snapshot.podcast_progress.len(), 10);
}
/// Pool that is never connected: the bridge paths under test resolve
/// podcast items, placeholders and inline content ids without queries.
fn offline_pool() -> sqlx::PgPool {
sqlx::postgres::PgPoolOptions::new()
.connect_lazy("postgres://offline@127.0.0.1:1/offline")
.unwrap()
}
#[tokio::test]
async fn podcast_queue_survives_server_browser_server_round_trip() {
let pool = offline_pool();
let mut other = test_episode();
other.episode_title = "Episode 43".into();
other.episode_id = EpisodeId::from_guid(&other.podcast_id, "episode-43").unwrap();
let mut unresolved = music_track(0);
unresolved.title = "Remote song".into();
let queue = vec![
PlaybackTrack::podcast_episode(test_episode()),
PlaybackTrack::private_placeholder(),
unresolved,
PlaybackTrack::podcast_episode(other),
];
let mut incoming = state(queue.clone());
incoming.queue_pos = 3;
incoming.paused = true;
incoming.position_secs = 1200.0;
// peer -> server -> browser
let payload = web_playback_payload(&pool, &incoming).await.unwrap();
let tracks = payload["tracks"].as_array().unwrap();
assert_eq!(tracks.len(), 4, "no item is dropped");
assert_eq!(payload["index"], 3);
assert_eq!(payload["position_seconds"], 1200.0);
assert_eq!(tracks[0]["source"]["kind"], "podcast_episode");
assert_eq!(tracks[0]["unavailable"], true);
assert_eq!(tracks[1]["source"]["kind"], "private");
// The browser keeps its queue and sends it back (plus a library track
// it added at the end, with its content id inline).
let mut browser: serde_json::Value = serde_json::from_str(&payload.to_string()).unwrap();
browser["tracks"]
.as_array_mut()
.unwrap()
.push(serde_json::json!({
"id": 77, "title": "Library song", "content_id": CONTENT_ID,
"duration_seconds": 100.0, "artists": [{"id": 1, "name": "A"}],
"release_id": 9, "release_title": "Album",
}));
// browser -> server -> peer
let outgoing = playback_state_from_browser_json(&pool, 1, browser)
.await
.unwrap();
assert_eq!(outgoing.queue[..4], queue[..]);
assert_eq!(outgoing.queue_pos, 3);
assert!(outgoing.paused);
// The episode position goes back to the peer (handoff web -> TUI).
assert_eq!(outgoing.position_secs, 1200.0);
let library = &outgoing.queue[4];
assert_eq!(library.id, 77);
assert_eq!(library.content_id.as_deref(), Some(CONTENT_ID));
assert_eq!(library.source, None);
// Library music keeps the v3 shape.
assert!(!serde_json::to_string(library).unwrap().contains("source"));
// Peers below v4 get no playback snapshot with these items.
assert!(!playback_allowed_for_peer(&outgoing, 3));
assert!(playback_allowed_for_peer(&outgoing, 4));
}
#[tokio::test]
async fn malformed_browser_items_keep_the_position_on_its_item() {
let pool = offline_pool();
let browser = serde_json::json!({
"tracks": [
{"title": "no id"},
{"id": 5, "content_id": CONTENT_ID},
{"id": 6, "content_id": CONTENT_ID},
],
"index": 2,
"track": {"id": 6},
});
let wire = playback_state_from_browser_json(&pool, 1, browser)
.await
.unwrap();
assert_eq!(wire.queue.len(), 2);
assert_eq!(wire.queue[wire.queue_pos].id, 6);
}
fn progress_record(position_ms: i64, status: ProgressStatus, generation: u64) -> ProgressRecord {
let episode = test_episode();
ProgressRecord {
episode_id: episode.episode_id,
podcast_id: episode.podcast_id,
position_ms,
status,
generation,
session_id: "session-1".into(),
hlc_ms: 1_700_000_000_000,
device_id: "tui".into(),
op_id: "op-1".into(),
}
}
/// Browser state of `[library song, episode]` with the song current at 200 s.
fn song_then_episode() -> serde_json::Value {
let episode = PlaybackTrack::podcast_episode(test_episode());
let song = serde_json::json!({
"id": 77, "title": "Library song", "content_id": CONTENT_ID,
"duration_seconds": 300.0, "stream_url": "/api/player/stream/77",
});
serde_json::json!({
"tracks": [song.clone(), queue_items::external_track_json(&episode, 1, None)],
"index": 0,
"track": song,
"position_seconds": 200.0,
"paused": false,
"repeat_mode": "off",
})
}
fn position_unknown(state: &serde_json::Value) -> bool {
state[queue_items::POSITION_UNKNOWN_KEY] == true
}
#[test]
fn commands_that_select_an_item_do_not_know_its_position() {
let current = song_then_episode();
// Next and Prev onto another item, and play commands (which the browser
// always sends with position 0), leave the position to the server.
let next =
browser_state_for_command("next", serde_json::json!({}), Some(current.clone())).unwrap();
assert_eq!(next["index"], 1);
assert_eq!(next["position_seconds"], 0.0);
assert!(position_unknown(&next));
let mut play = current.clone();
play["index"] = serde_json::json!(1);
let played = browser_state_for_command("play_from_index", play.clone(), None).unwrap();
assert!(position_unknown(&played));
let prev =
browser_state_for_command("prev", serde_json::json!({}), Some(next.clone())).unwrap();
assert_eq!(prev["index"], 0);
assert!(position_unknown(&prev));
// Restarting the same item and seeking are explicit positions.
let mut late = next.clone();
late["position_seconds"] = serde_json::json!(900.0);
let restart = browser_state_for_command("prev", serde_json::json!({}), Some(late)).unwrap();
assert_eq!(restart["index"], 1);
assert!(!position_unknown(&restart));
let repeat = browser_state_for_command(
"next",
serde_json::json!({"repeat_mode": "one"}),
Some(next.clone()),
)
.unwrap();
assert!(!position_unknown(&repeat));
let seek =
browser_state_for_command("seek", serde_json::json!({"time": 60.0}), Some(next)).unwrap();
assert_eq!(seek["position_seconds"], 60.0);
assert!(!position_unknown(&seek));
// A transfer keeps what the sender knew.
let mut handed_off = play;
handed_off["position_seconds"] = serde_json::json!(1200.0);
let transfer = browser_state_for_command("transfer_state", handed_off.clone(), None).unwrap();
assert_eq!(transfer["position_seconds"], 1200.0);
assert!(!position_unknown(&transfer));
handed_off[queue_items::POSITION_UNKNOWN_KEY] = serde_json::json!(true);
let transfer = browser_state_for_command("transfer_state", handed_off, None).unwrap();
assert!(position_unknown(&transfer));
}
#[tokio::test]
async fn unknown_episode_position_resumes_from_the_progress_register() {
let pool = offline_pool();
let next = browser_state_for_command("next", serde_json::json!({}), Some(song_then_episode()))
.unwrap();
let mut wire = browser_json_to_wire(&pool, next).await.unwrap();
assert_eq!(wire.queue_pos, 1);
assert_eq!(wire.position_secs, 0.0);
// In progress at 1200 s, generation 9 (the queue item has seen 7).
let mut resumed = wire.clone();
apply_resume_position(
&mut resumed,
Some(&progress_record(1_200_000, ProgressStatus::InProgress, 9)),
);
assert_eq!(resumed.position_secs, 1200.0);
let episode = resumed.queue[1].podcast_episode_ref().unwrap();
assert_eq!(episode.progress_generation, Some(9));
// The receiver's explicit write then orders after the register.
assert_eq!(
ProgressRecord::explicit_generation(episode.progress_generation),
10
);
// Completed: ordinary Play starts from the beginning; an older register
// does not lower the generation the item has seen.
let mut completed = wire.clone();
apply_resume_position(
&mut completed,
Some(&progress_record(1_790_000, ProgressStatus::Completed, 3)),
);
assert_eq!(completed.position_secs, 0.0);
assert_eq!(
completed.queue[1]
.podcast_episode_ref()
.unwrap()
.progress_generation,
Some(7)
);
// Music keeps the position it has.
wire.queue_pos = 0;
wire.position_secs = 5.0;
let before = wire.clone();
apply_resume_position(
&mut wire,
Some(&progress_record(1_200_000, ProgressStatus::InProgress, 9)),
);
assert_eq!(wire, before);
}
#[tokio::test]
async fn known_positions_and_music_never_read_the_progress_register() {
// The offline pool fails any query, so these conversions must not query.
let pool = offline_pool();
let mut handed_off = song_then_episode();
handed_off["index"] = serde_json::json!(1);
handed_off["position_seconds"] = serde_json::json!(1200.0);
let wire = playback_state_from_browser_json(&pool, 1, handed_off)
.await
.unwrap();
assert_eq!(wire.position_secs, 1200.0);
let mut music = song_then_episode();
music[queue_items::POSITION_UNKNOWN_KEY] = serde_json::json!(true);
let wire = playback_state_from_browser_json(&pool, 1, music)
.await
.unwrap();
assert_eq!(wire.position_secs, 200.0);
}
+3 -1
View File
@@ -1,5 +1,6 @@
//! Cross-binary protocol contract; the peer is the TUI's production adapter.
use super::*;
use music_dht::device_sync::read_line;
use tokio::io::AsyncWriteExt;
#[tokio::test]
@@ -34,7 +35,8 @@ async fn localhost_tui_peer() {
else {
panic!("expected TUI hello")
};
assert_eq!(profile.protocol_version, PROTOCOL_VERSION);
// TUI 0.3.x reports v3; podcast-capable TUI releases report v4.
assert!((3..=PROTOCOL_VERSION).contains(&profile.protocol_version));
assert_eq!(snapshot.device_id, profile.device_id);
let announcement = snapshot
.coordination
+478
View File
@@ -0,0 +1,478 @@
//! Device-sync v4 storage paths against PostgreSQL.
//!
//! Requires a migrated disposable database (start the server once against
//! it); the test writes rows for a random user id and removes them again.
use super::*;
use crate::player::queue_items::test_episode;
use music_dht::podcast::{
EpisodeId, FeedUrl, PodcastId, PodcastMeta, ProgressRecord, ProgressStatus, ShareRecord,
};
fn profile(device_id: &str, protocol_version: u16) -> DeviceProfileWire {
DeviceProfileWire {
device_id: device_id.into(),
name: device_id.to_uppercase(),
client_version: "test".into(),
protocol_version,
endpoint_id: String::new(),
endpoint_ticket: String::new(),
revoked: false,
revoke_cutoff_seq: None,
updated_at_ms: now_ms(),
}
}
fn op(origin: &str, seq: i64, hlc_ms: i64, payload: SyncOpPayload) -> SyncOpWire {
SyncOpWire {
op_id: format!("{origin}:{seq}"),
origin_device_id: origin.into(),
seq,
hlc_ms,
payload,
}
}
async fn cleanup(pool: &sqlx::PgPool, user_id: i64) {
for table in [
"furumusic__fed_device_identity",
"furumusic__fed_device",
"furumusic__fed_device_invite",
"furumusic__fed_peer_ack",
"furumusic__fed_pending_pairing",
"furumusic__fed_playback_applied",
"furumusic__fed_podcast_relay",
"furumusic__fed_state_like",
"furumusic__fed_state_playlist",
"furumusic__fed_state_playlist_item",
"furumusic__fed_sync_ops",
"furumusic__fed_sync_vector",
"furumusic__playback_state",
] {
sqlx::query(&format!("DELETE FROM {table} WHERE user_id = $1"))
.bind(user_id)
.execute(pool)
.await
.unwrap();
}
}
#[tokio::test]
#[ignore = "requires a migrated disposable database in FURU_DEVICE_SYNC_TEST_DATABASE_URL"]
async fn postgres_podcast_relay_gating_and_peer_versions() {
let pool = sqlx::PgPool::connect(&std::env::var("FURU_DEVICE_SYNC_TEST_DATABASE_URL").unwrap())
.await
.unwrap();
let user_id = 8_000_000_000 + i64::from(rand_suffix());
cleanup(&pool, user_id).await;
let new = format!("tui_new_{user_id}");
let old = format!("tui_old_{user_id}");
let other = format!("tui_other_{user_id}");
let identity = ensure_identity(&pool, user_id, "tester").await.unwrap();
// Peer versions: self-reports replace, relayed profiles only raise.
for (device, version) in [(&new, 4), (&old, 3), (&other, 4)] {
apply_device_profile(
&pool,
user_id,
&profile(device, version),
VersionReport::SelfReported(Some(version)),
true,
)
.await
.unwrap();
}
// A v3 relay lists everyone with its own constant.
apply_device_profiles(
&pool,
user_id,
&[profile(&new, 3), profile(&old, 3)],
Some(old.as_str()),
)
.await
.unwrap();
assert_eq!(
stored_protocol_version(&pool, user_id, &new).await.unwrap(),
4
);
assert_eq!(
stored_protocol_version(&pool, user_id, &old).await.unwrap(),
3
);
// Podcast and music operations from the v4 device.
let feed = FeedUrl::parse("https://podcasts.example/feed.xml").unwrap();
let podcast_id = PodcastId::from_feed_url(&feed);
let episode_id = EpisodeId::from_guid(&podcast_id, "ep-1").unwrap();
let meta: PodcastMeta = serde_json::from_value(serde_json::json!({
"feed_url": feed.as_str(), "title": "Example Cast"
}))
.unwrap();
let progress = |seq, generation, hlc_ms, position_ms| {
op(
&new,
seq,
hlc_ms,
SyncOpPayload::PodcastProgressSet {
episode_id: episode_id.clone(),
podcast_id: podcast_id.clone(),
position_ms,
status: ProgressStatus::InProgress,
generation,
session_id: format!("s{generation}"),
episode: None,
},
)
};
let mut invalid = progress(5, 9, 50, 1);
if let SyncOpPayload::PodcastProgressSet { session_id, .. } = &mut invalid.payload {
session_id.clear();
}
let hub = Arc::new(PlayerDeviceHub::default());
apply_ops(
&pool,
Arc::clone(&hub),
user_id,
vec![
op(
&new,
1,
10,
SyncOpPayload::PodcastSubscriptionSet {
podcast_id: podcast_id.clone(),
subscribed: true,
podcast: meta,
feed_aliases: vec![],
generation: 1,
},
),
// Newer generation first, then a late checkpoint of an older one.
progress(2, 4, 20, 10_000),
progress(3, 3, 90_000, 600_000),
op(
&new,
4,
40,
SyncOpPayload::TrackLikeSet {
content_id: format!("b3:{}", "3".repeat(64)),
liked: false,
fed: None,
},
),
invalid,
],
)
.await
.unwrap();
// The invalid operation is not stored but acknowledged.
assert_eq!(vector(&pool, user_id).await.unwrap().get(&new), Some(&5));
let stored: i64 = sqlx::query_scalar(
"SELECT COUNT(*) FROM furumusic__fed_sync_ops WHERE user_id = $1 AND origin_device_id = $2",
)
.bind(user_id)
.bind(&new)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(stored, 4);
// Relay: the v3 peer gets only music, a v4 peer gets everything.
let kinds = |ops: Vec<SyncOpWire>| {
ops.iter()
.map(|op| payload_kind(&op.payload))
.collect::<Vec<_>>()
};
let to_old = kinds(ops_for_peer(&pool, user_id, &old, 3).await.unwrap());
assert!(to_old.iter().all(|kind| !kind.starts_with("podcast_")));
assert!(to_old.contains(&"track_like_set"));
let to_other = kinds(ops_for_peer(&pool, user_id, &other, 4).await.unwrap());
assert_eq!(
to_other
.iter()
.filter(|kind| kind.starts_with("podcast_"))
.count(),
3
);
// Snapshot recovery: registers merged with the shared rules.
apply_snapshot(
&pool,
user_id,
SyncSnapshot {
podcast_shares: vec![ShareRecord {
podcast_id: podcast_id.clone(),
shared: false,
generation: 2,
hlc_ms: 60,
op_id: format!("{other}:1"),
}],
podcast_progress: vec![ProgressRecord {
episode_id: episode_id.clone(),
podcast_id: podcast_id.clone(),
position_ms: 1,
status: ProgressStatus::InProgress,
generation: 2,
session_id: "old".into(),
hlc_ms: 999_999,
device_id: other.clone(),
op_id: format!("{other}:2"),
}],
..SyncSnapshot::default()
},
)
.await
.unwrap();
let full = snapshot(&pool, user_id).await.unwrap();
assert_eq!(full.podcast_subscriptions.len(), 1);
assert_eq!(full.podcast_shares.len(), 1);
assert_eq!(full.podcast_progress.len(), 1);
assert_eq!(full.podcast_progress[0].position_ms, 10_000);
assert_eq!(full.podcast_progress[0].generation, 4);
assert!(!full.for_peer(3).has_podcast_state());
assert_eq!(full.for_peer(4), full);
// A DeviceProfileSet with a version is a self-report of its origin.
apply_ops(
&pool,
Arc::clone(&hub),
user_id,
vec![op(
&old,
1,
70,
SyncOpPayload::DeviceProfileSet {
name: "OLD".into(),
client_version: "0.4.0".into(),
endpoint_ticket: String::new(),
endpoint_id: String::new(),
protocol_version: Some(4),
},
)],
)
.await
.unwrap();
assert_eq!(
stored_protocol_version(&pool, user_id, &old).await.unwrap(),
4
);
// First start after the upgrade announces the new version once.
sqlx::query(
"UPDATE furumusic__fed_device SET protocol_version = 3
WHERE user_id = $1 AND device_id = $2",
)
.bind(user_id)
.bind(&identity.device_id)
.execute(&pool)
.await
.unwrap();
own_profile(&pool, user_id, "", "").await.unwrap();
own_profile(&pool, user_id, "", "").await.unwrap();
let announced: Vec<serde_json::Value> = sqlx::query_scalar(
"SELECT payload_json FROM furumusic__fed_sync_ops
WHERE user_id = $1 AND origin_device_id = $2 AND kind = 'device_profile_set'",
)
.bind(user_id)
.bind(&identity.device_id)
.fetch_all(&pool)
.await
.unwrap();
assert_eq!(announced.len(), 1);
assert_eq!(announced[0]["protocol_version"], 4);
// Handoff gating: refused for the v3 device, allowed for v4.
let queue = PlaybackStateWire {
queue: vec![PlaybackTrack::podcast_episode(test_episode())],
queue_pos: 0,
playing: true,
paused: false,
idle_since_ms: None,
position_secs: 0.0,
volume: 50,
shuffle: false,
repeat: PlaybackRepeat::Off,
playback_rate: None,
};
sqlx::query(
"UPDATE furumusic__fed_device SET protocol_version = 3
WHERE user_id = $1 AND device_id = $2",
)
.bind(user_id)
.bind(&old)
.execute(&pool)
.await
.unwrap();
let refused = ensure_playback_supported_by(&pool, user_id, &old, &queue)
.await
.unwrap_err();
assert!(refused.to_string().contains("needs an update"));
ensure_playback_supported_by(&pool, user_id, &other, &queue)
.await
.unwrap();
// The typed queue column exists next to queue_json.
sqlx::query("SELECT queue_json, queue_items_json FROM furumusic__playback_state LIMIT 0")
.execute(&pool)
.await
.unwrap();
cleanup(&pool, user_id).await;
}
#[tokio::test]
#[ignore = "requires a migrated disposable database in FURU_DEVICE_SYNC_TEST_DATABASE_URL"]
async fn postgres_unknown_episode_position_and_rollback_cleanup() {
let pool = sqlx::PgPool::connect(&std::env::var("FURU_DEVICE_SYNC_TEST_DATABASE_URL").unwrap())
.await
.unwrap();
let user_id = 8_000_000_000 + i64::from(rand_suffix());
cleanup(&pool, user_id).await;
let tui = format!("tui_{user_id}");
ensure_identity(&pool, user_id, "tester").await.unwrap();
apply_device_profile(
&pool,
user_id,
&profile(&tui, 4),
VersionReport::SelfReported(Some(4)),
true,
)
.await
.unwrap();
// The TUI left the episode at 1200 s (generation 9; queue items saw 7).
let episode = test_episode();
let hub = Arc::new(PlayerDeviceHub::default());
apply_ops(
&pool,
Arc::clone(&hub),
user_id,
vec![op(
&tui,
1,
10,
SyncOpPayload::PodcastProgressSet {
episode_id: episode.episode_id.clone(),
podcast_id: episode.podcast_id.clone(),
position_ms: 1_200_000,
status: ProgressStatus::InProgress,
generation: 9,
session_id: "s9".into(),
episode: None,
},
)],
)
.await
.unwrap();
// The web player reached the episode by Next and does not know where it
// was left; it hands playback to the TUI.
let song = serde_json::json!({
"id": 77, "title": "Library song", "content_id": format!("b3:{}", "4".repeat(64)),
"duration_seconds": 300.0,
});
let item = crate::player::queue_items::external_track_json(
&PlaybackTrack::podcast_episode(episode.clone()),
1,
None,
);
let browser = serde_json::json!({
"tracks": [song.clone(), item.clone()], "index": 1, "track": item.clone(),
"position_seconds": 0.0, "paused": true, "position_unknown": true,
});
record_web_active_transfer(&pool, user_id, &tui, None, browser)
.await
.unwrap();
let sent: serde_json::Value = sqlx::query_scalar(
"SELECT payload_json FROM furumusic__fed_sync_ops
WHERE user_id = $1 AND kind = 'playback_command' ORDER BY seq DESC LIMIT 1",
)
.bind(user_id)
.fetch_one(&pool)
.await
.unwrap();
let SyncOpPayload::PlaybackCommand {
command: PlaybackCommand::ActiveChanged { state, .. },
..
} = serde_json::from_value(sent).unwrap()
else {
panic!("expected ActiveChanged");
};
assert_eq!(state.position_secs, 1200.0, "never 0");
assert_eq!(
state.queue[1]
.podcast_episode_ref()
.unwrap()
.progress_generation,
Some(9)
);
// Remote Next onto the episode while the TUI plays the song.
let current = serde_json::json!({
"tracks": [song, item], "index": 0, "track": song,
"position_seconds": 200.0, "paused": false,
});
let next = record_web_playback_command(
&pool,
user_id,
&tui,
"next",
serde_json::json!({}),
Some(current),
)
.await
.unwrap();
assert_eq!(next["index"], 1);
assert_eq!(next["position_seconds"], 1200.0);
assert!(
next.get(crate::player::queue_items::POSITION_UNKNOWN_KEY)
.is_none()
);
// Rollback to 0.12: its types fail on the relayed podcast operation, and
// parse everything once the documented cleanup ran.
let parse_like_0_12 = |rows: Vec<serde_json::Value>| {
rows.into_iter()
.map(serde_json::from_value::<super::wire_compat_tests::legacy::SyncOpPayload>)
.collect::<Result<Vec<_>, _>>()
};
let rows = || async {
sqlx::query_scalar::<_, serde_json::Value>(
"SELECT payload_json FROM furumusic__fed_sync_ops WHERE user_id = $1",
)
.bind(user_id)
.fetch_all(&pool)
.await
.unwrap()
};
assert!(parse_like_0_12(rows().await).is_err());
sqlx::query(&format!(
"{} AND user_id = $1",
crate::music::db_migrations::DELETE_PODCAST_SYNC_OPS_SQL
))
.bind(user_id)
.execute(&pool)
.await
.unwrap();
let remaining = parse_like_0_12(rows().await).unwrap();
// The playback commands (with the episode's `source`) stay readable.
assert_eq!(
remaining
.iter()
.filter(|payload| matches!(
payload,
super::wire_compat_tests::legacy::SyncOpPayload::PlaybackCommand { .. }
))
.count(),
2
);
cleanup(&pool, user_id).await;
}
fn rand_suffix() -> u32 {
u32::from_le_bytes(
blake3::hash(random_hex(8).as_bytes()).as_bytes()[..4]
.try_into()
.unwrap(),
) % 1_000_000_000
}
+524
View File
@@ -0,0 +1,524 @@
//! Golden wire-compatibility tests: the shared `music_dht::device_sync`
//! types must serialize v3 content byte-for-byte like the private copies that
//! furumi-web 0.12.x used (kept verbatim in `legacy` below), so TUI 0.3.x and
//! older web servers keep interoperating.
use super::*;
/// Private wire types of furumi-web 0.12.4 (`src/federation/devices.rs`),
/// copied verbatim apart from visibility and `PartialEq`.
#[allow(dead_code)]
pub(super) mod legacy {
use music_dht::device_sync::ListenEvent;
use music_dht::playback::CommandStamp;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InviteWire {
pub v: u16,
#[serde(rename = "t")]
pub ticket: String,
#[serde(rename = "d")]
pub device_id: String,
#[serde(rename = "i")]
pub invite_id: String,
#[serde(rename = "s")]
pub secret: String,
#[serde(rename = "e")]
pub expires_at_ms: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DeviceProfileWire {
pub device_id: String,
pub name: String,
pub client_version: String,
pub protocol_version: u16,
pub endpoint_id: String,
pub endpoint_ticket: String,
#[serde(default)]
pub revoked: bool,
#[serde(default)]
pub revoke_cutoff_seq: Option<i64>,
#[serde(default)]
pub updated_at_ms: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SyncedFedTrack {
pub item_id: String,
pub owner: String,
pub title: String,
#[serde(default)]
pub artist_names: Vec<String>,
#[serde(default)]
pub featured_artist_names: Vec<String>,
pub year: Option<i32>,
pub duration_seconds: Option<i64>,
pub content_id: String,
pub release_title: Option<String>,
pub track_number: Option<i32>,
pub disc_number: Option<i32>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlaybackTrack {
pub id: i64,
pub title: String,
pub track_number: Option<i32>,
pub disc_number: Option<i32>,
pub duration_seconds: f64,
#[serde(default)]
pub artist_names: Vec<String>,
#[serde(default)]
pub featured_artist_names: Vec<String>,
pub release_id: i64,
pub release_title: String,
pub release_year: Option<i32>,
#[serde(default)]
pub file_path: String,
pub content_id: Option<String>,
pub audio_format: Option<String>,
pub audio_bitrate: Option<i32>,
pub audio_sample_rate: Option<i32>,
pub audio_bit_depth: Option<i32>,
pub file_size_bytes: Option<i64>,
#[serde(default)]
pub play_count: i64,
#[serde(default)]
pub fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum PlaybackRepeat {
#[default]
Off,
One,
All,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlaybackStateWire {
#[serde(default)]
pub queue: Vec<PlaybackTrack>,
#[serde(default)]
pub queue_pos: usize,
pub playing: bool,
pub paused: bool,
#[serde(default)]
pub idle_since_ms: Option<i64>,
pub position_secs: f64,
#[serde(default)]
pub volume: u8,
pub shuffle: bool,
pub repeat: PlaybackRepeat,
}
pub type PlaybackSnapshot = music_dht::playback::Snapshot<PlaybackStateWire>;
pub type PlaybackCommand = music_dht::playback::Command<PlaybackStateWire>;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncOpWire {
pub op_id: String,
pub origin_device_id: String,
pub seq: i64,
pub hlc_ms: i64,
pub payload: SyncOpPayload,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum SyncOpPayload {
TrackLikeSet {
content_id: String,
liked: bool,
#[serde(default)]
fed: Option<SyncedFedTrack>,
},
PlaylistCreated {
playlist_id: String,
title: String,
},
PlaylistRenamed {
playlist_id: String,
title: String,
},
PlaylistDeleted {
playlist_id: String,
},
PlaylistTrackAdded {
playlist_id: String,
content_id: String,
position: i64,
#[serde(default)]
fed: Option<SyncedFedTrack>,
},
PlaylistTrackRemoved {
playlist_id: String,
content_id: String,
},
DeviceProfileSet {
name: String,
client_version: String,
endpoint_ticket: String,
endpoint_id: String,
},
DeviceTrusted {
target_device_id: String,
},
DeviceRevoked {
target_device_id: String,
target_max_seq_seen: i64,
},
PlaybackCommand {
target_device_id: String,
command: PlaybackCommand,
#[serde(default)]
authority: Option<CommandStamp>,
},
ListenRecorded {
event: ListenEvent,
},
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SyncSnapshot {
#[serde(default)]
pub likes: Vec<SnapshotLike>,
#[serde(default)]
pub unlikes: Vec<SnapshotLikeTombstone>,
#[serde(default)]
pub playlists: Vec<SnapshotPlaylist>,
#[serde(default)]
pub deleted_playlists: Vec<SnapshotPlaylistTombstone>,
#[serde(default)]
pub removed_playlist_items: Vec<SnapshotPlaylistItemTombstone>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotLike {
pub content_id: String,
pub hlc_ms: i64,
pub op_id: String,
#[serde(default)]
pub fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotLikeTombstone {
pub content_id: String,
pub hlc_ms: i64,
pub op_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPlaylist {
pub playlist_id: String,
pub title: String,
pub hlc_ms: i64,
pub op_id: String,
#[serde(default)]
pub items: Vec<SnapshotPlaylistItem>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPlaylistTombstone {
pub playlist_id: String,
pub hlc_ms: i64,
pub op_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPlaylistItem {
pub content_id: String,
pub position: i64,
pub hlc_ms: i64,
pub op_id: String,
#[serde(default)]
pub fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPlaylistItemTombstone {
pub playlist_id: String,
pub content_id: String,
pub hlc_ms: i64,
pub op_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum WireMessage {
PairRequest {
invite_id: String,
secret: String,
profile: DeviceProfileWire,
#[serde(default)]
group_id: Option<String>,
#[serde(default)]
group_active_devices: usize,
#[serde(default)]
devices: Vec<DeviceProfileWire>,
vector: BTreeMap<String, i64>,
ops: Vec<SyncOpWire>,
snapshot: SyncSnapshot,
#[serde(default)]
playback: Option<PlaybackSnapshot>,
},
PairResponse {
accepted: bool,
#[serde(default)]
pending: bool,
#[serde(default)]
error: Option<String>,
#[serde(default)]
group_id: Option<String>,
#[serde(default)]
profile: Option<DeviceProfileWire>,
#[serde(default)]
devices: Vec<DeviceProfileWire>,
#[serde(default)]
vector: BTreeMap<String, i64>,
#[serde(default)]
ops: Vec<SyncOpWire>,
#[serde(default)]
snapshot: SyncSnapshot,
#[serde(default)]
playback: Option<PlaybackSnapshot>,
},
Hello {
group_id: String,
profile: DeviceProfileWire,
devices: Vec<DeviceProfileWire>,
vector: BTreeMap<String, i64>,
ops: Vec<SyncOpWire>,
snapshot: SyncSnapshot,
#[serde(default)]
playback: Option<PlaybackSnapshot>,
},
SyncResponse {
accepted: bool,
#[serde(default)]
error: Option<String>,
#[serde(default)]
devices: Vec<DeviceProfileWire>,
#[serde(default)]
vector: BTreeMap<String, i64>,
#[serde(default)]
ops: Vec<SyncOpWire>,
#[serde(default)]
snapshot: SyncSnapshot,
#[serde(default)]
playback: Option<PlaybackSnapshot>,
},
}
}
const CONTENT_ID: &str = "b3:1111111111111111111111111111111111111111111111111111111111111111";
/// A v3 `hello` exercising every v3 operation kind, every snapshot section
/// and a coordinated playback snapshot (input order is irrelevant).
fn v3_hello_input() -> String {
let fed = serde_json::json!({
"item_id": "item", "owner": "owner", "title": "Song", "artist_names": ["A"],
"featured_artist_names": [], "year": 2001, "duration_seconds": 180,
"content_id": CONTENT_ID, "release_title": "Album", "track_number": 1, "disc_number": 1,
});
let track = serde_json::json!({
"id": 7, "title": "Song", "track_number": 1, "disc_number": null,
"duration_seconds": 180.5, "artist_names": ["A"], "featured_artist_names": ["B"],
"release_id": 3, "release_title": "Album", "release_year": 2001, "file_path": "",
"content_id": CONTENT_ID, "audio_format": "flac", "audio_bitrate": 900,
"audio_sample_rate": 44100, "audio_bit_depth": 16, "file_size_bytes": 12345,
"play_count": 2, "fed": fed,
});
let state = serde_json::json!({
"queue": [track, {"id": 0, "title": "Remote", "track_number": null, "disc_number": null,
"duration_seconds": 0.0, "release_id": 0, "release_title": "", "release_year": null,
"content_id": null, "audio_format": null, "audio_bitrate": null,
"audio_sample_rate": null, "audio_bit_depth": null, "file_size_bytes": null}],
"queue_pos": 1, "playing": true, "paused": false, "idle_since_ms": null,
"position_secs": 42.5, "volume": 73, "shuffle": true, "repeat": "all",
});
let claim = serde_json::json!({"counter": 3, "issuer": "tui_a", "owner": "tui_a"});
let stamp = serde_json::json!({"version": 1, "claim": claim, "sequence": 9});
let op = |seq: i64, payload: serde_json::Value| {
serde_json::json!({"op_id": format!("tui_a:{seq}"), "origin_device_id": "tui_a",
"seq": seq, "hlc_ms": 1_700_000_000_000i64 + seq, "payload": payload})
};
let profile = |id: &str| {
serde_json::json!({"device_id": id, "name": "TUI", "client_version": "0.3.4",
"protocol_version": 3, "endpoint_id": "e", "endpoint_ticket": "t",
"revoked": false, "revoke_cutoff_seq": null, "updated_at_ms": 5})
};
serde_json::json!({
"type": "hello",
"group_id": "grp_1",
"profile": profile("tui_a"),
"devices": [profile("tui_a"), profile("web_b")],
"vector": {"tui_a": 12, "web_b": 4},
"ops": [
op(1, serde_json::json!({"kind": "track_like_set", "content_id": CONTENT_ID, "liked": true, "fed": fed})),
op(2, serde_json::json!({"kind": "playlist_created", "playlist_id": "pl", "title": "Mix"})),
op(3, serde_json::json!({"kind": "playlist_renamed", "playlist_id": "pl", "title": "Mix 2"})),
op(4, serde_json::json!({"kind": "playlist_track_added", "playlist_id": "pl", "content_id": CONTENT_ID, "position": 0, "fed": null})),
op(5, serde_json::json!({"kind": "playlist_track_removed", "playlist_id": "pl", "content_id": CONTENT_ID})),
op(6, serde_json::json!({"kind": "playlist_deleted", "playlist_id": "pl"})),
op(7, serde_json::json!({"kind": "device_profile_set", "name": "TUI", "client_version": "0.3.4", "endpoint_ticket": "t", "endpoint_id": "e"})),
op(8, serde_json::json!({"kind": "device_trusted", "target_device_id": "web_b"})),
op(9, serde_json::json!({"kind": "device_revoked", "target_device_id": "old", "target_max_seq_seen": 3})),
op(10, serde_json::json!({"kind": "playback_command", "target_device_id": "web_b",
"command": {"kind": "set_state", "state": state, "seek": true}, "authority": stamp})),
op(11, serde_json::json!({"kind": "playback_command", "target_device_id": "web_b",
"command": {"kind": "active_changed", "active_device_id": "web_b", "active_device_name": "WEB", "state": state}})),
op(12, serde_json::json!({"kind": "listen_recorded", "event": {"listen_id": "l1",
"content_id": CONTENT_ID, "started_at_ms": 1, "listened_ms": 60000, "track_duration_ms": 180000,
"ended_reason": "finished", "track": {"title": "Song", "artist_names": ["A"], "featured_artist_names": [], "release_title": null}}})),
],
"snapshot": {
"likes": [{"content_id": CONTENT_ID, "hlc_ms": 1, "op_id": "tui_a:1", "fed": fed}],
"unlikes": [{"content_id": CONTENT_ID, "hlc_ms": 2, "op_id": "tui_a:2"}],
"playlists": [{"playlist_id": "pl", "title": "Mix", "hlc_ms": 3, "op_id": "tui_a:3",
"items": [{"content_id": CONTENT_ID, "position": 0, "hlc_ms": 4, "op_id": "tui_a:4", "fed": null}]}],
"deleted_playlists": [{"playlist_id": "gone", "hlc_ms": 5, "op_id": "tui_a:5"}],
"removed_playlist_items": [{"playlist_id": "pl", "content_id": CONTENT_ID, "hlc_ms": 6, "op_id": "tui_a:6"}],
},
"playback": {"device_id": "tui_a", "device_name": "TUI", "active": true, "updated_at_ms": 9,
"state": state, "coordination": {"version": 1, "claim": claim, "heartbeat": 4, "available": true, "playing": true}},
})
.to_string()
}
fn v3_other_inputs() -> Vec<String> {
vec![
r#"{"type":"sync_response","accepted":false,"error":"device is not trusted"}"#.into(),
r#"{"type":"pair_response","accepted":false,"pending":true,"error":"pairing pending"}"#
.into(),
serde_json::json!({"type": "pair_request", "invite_id": "i", "secret": "s",
"profile": {"device_id": "tui_a", "name": "TUI", "client_version": "0.3.4",
"protocol_version": 3, "endpoint_id": "e", "endpoint_ticket": "t"},
"vector": {}, "ops": [], "snapshot": {}})
.to_string(),
]
}
/// Parses `input` with the 0.12.x types and the shared types and checks
/// that both serialize to the same bytes, and that each side parses the
/// other's output.
fn assert_identical(input: &str) -> String {
let old: legacy::WireMessage = serde_json::from_str(input).unwrap();
let new: WireMessage = serde_json::from_str(input).unwrap();
let old_json = serde_json::to_string(&old).unwrap();
let new_json = serde_json::to_string(&new).unwrap();
assert_eq!(old_json, new_json);
assert_eq!(
serde_json::from_str::<legacy::WireMessage>(&new_json).unwrap(),
old
);
assert_eq!(serde_json::from_str::<WireMessage>(&old_json).unwrap(), new);
new_json
}
#[test]
fn v3_messages_serialize_like_furumi_web_0_12() {
let hello = assert_identical(&v3_hello_input());
let golden = concat!(
env!("CARGO_MANIFEST_DIR"),
"/src/federation/devices/fixtures/v3_hello.golden.json"
);
if std::env::var_os("FURUMUSIC_BLESS_GOLDEN").is_some() {
// Only for a deliberate change of the v3 shape.
std::fs::write(golden, format!("{hello}\n")).unwrap();
}
assert_eq!(hello, std::fs::read_to_string(golden).unwrap().trim_end());
for input in v3_other_inputs() {
assert_identical(&input);
}
}
#[test]
fn invites_stay_readable_by_older_clients() {
let old = legacy::InviteWire {
v: 1,
ticket: "ticket".into(),
device_id: "web_a".into(),
invite_id: "inv".into(),
secret: "s3cr3t".into(),
expires_at_ms: 10,
};
let old_json = serde_json::to_string(&old).unwrap();
assert_eq!(
old_json,
r#"{"v":1,"t":"ticket","d":"web_a","i":"inv","s":"s3cr3t","e":10}"#
);
let shared: InviteWire = serde_json::from_str(&old_json).unwrap();
assert_eq!(shared.inviter_protocol_version(), 1);
assert_eq!(serde_json::to_string(&shared).unwrap(), old_json);
let link = encode_invite(&InviteWire {
protocol_version: Some(PROTOCOL_VERSION),
..shared
})
.unwrap();
let parsed = parse_invite(&link).unwrap();
assert_eq!(parsed.inviter_protocol_version(), PROTOCOL_VERSION);
// `p` is an unknown field for 0.12.x and is ignored there.
let token = link.strip_prefix("frid://i/").unwrap();
assert!(!token.is_empty());
let json = serde_json::to_string(&parsed).unwrap();
assert!(json.ends_with(r#","p":4}"#));
assert_eq!(
serde_json::from_str::<legacy::InviteWire>(&json).unwrap(),
old
);
}
#[test]
fn v3_peers_cannot_parse_podcast_operations() {
// Why podcast operations must be gated: an unknown `kind` breaks the
// whole message for a 0.12.x/TUI 0.3.x peer, not one operation.
let mut hello: serde_json::Value = serde_json::from_str(&v3_hello_input()).unwrap();
hello["ops"].as_array_mut().unwrap().push(serde_json::json!({
"op_id": "tui_a:13", "origin_device_id": "tui_a", "seq": 13, "hlc_ms": 13,
"payload": {"kind": "podcast_share_set",
"podcast_id": music_dht::podcast::PodcastId::from_feed_url(
&music_dht::podcast::FeedUrl::parse("https://podcasts.example/feed.xml").unwrap()),
"shared": false, "generation": 1},
}));
assert!(serde_json::from_value::<legacy::WireMessage>(hello.clone()).is_err());
assert!(serde_json::from_value::<WireMessage>(hello).is_ok());
}
#[test]
fn v3_peers_would_drop_the_source_of_podcast_items() {
// Why podcast playback must be gated: older types ignore `source` and
// forward the episode as a broken music item.
let episode = PlaybackTrack::podcast_episode(crate::player::queue_items::test_episode());
let json = serde_json::to_string(&episode).unwrap();
assert!(json.contains(r#""source":{"kind":"podcast_episode""#));
let old: legacy::PlaybackTrack = serde_json::from_str(&json).unwrap();
let forwarded: PlaybackTrack =
serde_json::from_str(&serde_json::to_string(&old).unwrap()).unwrap();
assert_eq!(forwarded.source, None);
assert_eq!(forwarded.id, 0);
}
#[test]
fn v4_profile_announcements_stay_readable_by_older_clients() {
let announcement = SyncOpPayload::DeviceProfileSet {
name: "WEB".into(),
client_version: "0.13.0".into(),
endpoint_ticket: "t".into(),
endpoint_id: "e".into(),
protocol_version: Some(PROTOCOL_VERSION),
};
let json = serde_json::to_string(&announcement).unwrap();
assert!(json.ends_with(r#","protocol_version":4}"#));
// 0.12.x and TUI 0.3.x ignore the new field.
let old: legacy::SyncOpPayload = serde_json::from_str(&json).unwrap();
assert!(matches!(
old,
legacy::SyncOpPayload::DeviceProfileSet { .. }
));
}
+13
View File
@@ -17,6 +17,7 @@
mod capabilities;
pub mod client;
pub mod devices;
mod podcast_relay;
mod receive;
mod serve;
mod similarity;
@@ -1192,6 +1193,18 @@ impl Federation {
.await
}
/// Refuses a transfer that the target device cannot receive (podcast
/// items for a device below protocol v4) before ownership changes.
pub async fn fed_device_web_transfer_check(
&self,
user_id: i64,
target_device_id: &str,
state: serde_json::Value,
) -> Result<()> {
let pool = self.pool().await?;
devices::check_web_transfer(&pool, user_id, target_device_id, state).await
}
pub async fn fed_device_web_active_takeover(
&self,
user_id: i64,
+575
View File
@@ -0,0 +1,575 @@
//! Lossless relay of podcast sync state (device-sync protocol v4).
//!
//! The web server does not implement podcasts yet, but it announces protocol
//! v4 and therefore must not lose podcast state that trusted devices send
//! through it:
//!
//! * podcast operations are stored verbatim in the generic operation log
//! (`furumusic__fed_sync_ops`) and forwarded to v4 peers only;
//! * the podcast registers carried by those operations and by snapshot
//! sections are kept here as opaque JSON documents, merged with the shared
//! `music_dht::podcast` rules, and returned in this device's snapshots.
//! Snapshots are the only recovery path for a peer that skipped podcast
//! operations while it ran an older version.
//!
//! The rows hold the shared contract types (`SubscriptionRecord`,
//! `ShareRecord`, `ProgressRecord`, `ListenSession`) as JSON and nothing
//! web-specific; a later podcast store can import them.
use anyhow::Result;
use music_dht::device_sync::{SyncOpWire, SyncSnapshot};
use music_dht::podcast::{
FeedUrl, ListenSession, PodcastId, ProgressRecord, ShareRecord, SubscriptionRecord,
merge_feed_aliases, merge_listen_session, merge_progress, merge_share, merge_subscription,
};
use serde::Serialize;
use serde::de::DeserializeOwned;
use serde_json::Value;
use sqlx::Row;
const SECTION_SUBSCRIPTION: &str = "subscription";
const SECTION_SHARE: &str = "share";
const SECTION_ALIASES: &str = "aliases";
const SECTION_PROGRESS: &str = "progress";
const SECTION_SESSION: &str = "session";
/// One podcast register update, keyed by its entity.
#[derive(Debug, Clone, PartialEq)]
pub(crate) enum RelayRecord {
/// Subscription register of a podcast.
Subscription(SubscriptionRecord),
/// Share register of a podcast.
Share(ShareRecord),
/// Feed aliases learned before (or without) the subscription register.
Aliases(PodcastId, Vec<FeedUrl>),
/// Progress register of an episode.
Progress(ProgressRecord),
/// Listening session.
Session(ListenSession),
}
impl RelayRecord {
fn section(&self) -> &'static str {
match self {
RelayRecord::Subscription(_) => SECTION_SUBSCRIPTION,
RelayRecord::Share(_) => SECTION_SHARE,
RelayRecord::Aliases(..) => SECTION_ALIASES,
RelayRecord::Progress(_) => SECTION_PROGRESS,
RelayRecord::Session(_) => SECTION_SESSION,
}
}
fn key(&self) -> &str {
match self {
RelayRecord::Subscription(record) => record.podcast_id.as_str(),
RelayRecord::Share(record) => record.podcast_id.as_str(),
RelayRecord::Aliases(podcast_id, _) => podcast_id.as_str(),
RelayRecord::Progress(record) => record.episode_id.as_str(),
RelayRecord::Session(session) => session.session_id.as_str(),
}
}
/// Register updates carried by a podcast operation.
///
/// Operations that fail `validate_podcast` must be dropped before this.
pub(crate) fn from_op(op: &SyncOpWire) -> Option<Self> {
if let Some(record) = op.podcast_subscription() {
return Some(RelayRecord::Subscription(record));
}
if let Some(record) = op.podcast_share() {
return Some(RelayRecord::Share(record));
}
if let Some((podcast_id, aliases)) = op.podcast_feed_aliases() {
return Some(RelayRecord::Aliases(podcast_id.clone(), aliases.to_vec()));
}
if let Some(record) = op.podcast_progress() {
return Some(RelayRecord::Progress(record));
}
op.podcast_listen_session()
.map(|session| RelayRecord::Session(session.clone()))
}
/// Valid register records of a snapshot. Podcast sections that exceed
/// the contract counts are ignored as a whole; invalid records are
/// skipped one by one.
pub(crate) fn from_snapshot(snapshot: &SyncSnapshot) -> Vec<Self> {
if !snapshot.podcast_state_within_limits() {
tracing::debug!("ignored podcast snapshot sections above the contract limits");
return Vec::new();
}
let subscriptions = snapshot
.podcast_subscriptions
.iter()
.filter(|record| record.validate().is_ok())
.cloned()
.map(RelayRecord::Subscription);
let shares = snapshot
.podcast_shares
.iter()
.filter(|record| record.validate().is_ok())
.cloned()
.map(RelayRecord::Share);
let progress = snapshot
.podcast_progress
.iter()
.filter(|record| record.validate().is_ok())
.cloned()
.map(RelayRecord::Progress);
let sessions = snapshot
.podcast_listen_sessions
.iter()
.filter(|session| session.validate().is_ok())
.cloned()
.map(RelayRecord::Session);
subscriptions
.chain(shares)
.chain(progress)
.chain(sessions)
.collect()
}
}
/// Document address: `(section, record_key)`.
type DocKey = (&'static str, String);
/// Documents a record's merge reads.
fn read_keys(record: &RelayRecord) -> Vec<DocKey> {
let own = (record.section(), record.key().to_string());
match record {
RelayRecord::Aliases(podcast_id, _) => {
vec![(SECTION_SUBSCRIPTION, podcast_id.as_str().to_string()), own]
}
RelayRecord::Subscription(_) => {
vec![(SECTION_ALIASES, record.key().to_string()), own]
}
_ => vec![own],
}
}
/// Merges `incoming` into the stored documents with the shared rules.
///
/// Returns the writes: `Some(value)` upserts, `None` deletes. Aliases
/// learned before the subscription register are kept in their own document
/// and folded into the register when it arrives.
fn plan_merge(
docs: &std::collections::BTreeMap<DocKey, Value>,
incoming: &RelayRecord,
) -> Vec<(DocKey, Option<Value>)> {
let own = (incoming.section(), incoming.key().to_string());
let current = docs.get(&own);
let changed = |merged: Option<Value>| {
merged
.filter(|merged| current != Some(merged))
.map(|merged| (own.clone(), Some(merged)))
};
match incoming {
RelayRecord::Subscription(record) => {
let alias_key = (SECTION_ALIASES, incoming.key().to_string());
let pending = docs.get(&alias_key).and_then(parse::<Vec<FeedUrl>>);
let merged = match current.and_then(parse::<SubscriptionRecord>) {
Some(current) => merge_subscription(&current, record).ok(),
None => {
let mut record = record.clone();
record.normalize();
Some(record)
}
}
.map(|mut record| {
if let Some(aliases) = &pending {
record.add_feed_aliases(aliases);
}
record
});
let mut writes: Vec<_> = changed(merged.as_ref().and_then(to_value))
.into_iter()
.collect();
if docs.contains_key(&alias_key) && merged.is_some() {
writes.push((alias_key, None));
}
writes
}
RelayRecord::Aliases(podcast_id, aliases) => {
let sub_key = (SECTION_SUBSCRIPTION, podcast_id.as_str().to_string());
if let Some(subscription) = docs.get(&sub_key) {
let Some(mut record) = parse::<SubscriptionRecord>(subscription) else {
return Vec::new();
};
record.add_feed_aliases(aliases);
return to_value(&record)
.filter(|merged| merged != subscription)
.map(|merged| vec![(sub_key, Some(merged))])
.unwrap_or_default();
}
let current = current.and_then(parse::<Vec<FeedUrl>>).unwrap_or_default();
changed(to_value(&merge_feed_aliases(podcast_id, &current, aliases)))
.into_iter()
.collect()
}
RelayRecord::Share(record) => changed(match current.and_then(parse::<ShareRecord>) {
Some(current) => merge_share(&current, record)
.ok()
.as_ref()
.and_then(to_value),
None => to_value(record),
})
.into_iter()
.collect(),
RelayRecord::Progress(record) => changed(match current.and_then(parse::<ProgressRecord>) {
Some(current) => merge_progress(&current, record)
.ok()
.as_ref()
.and_then(to_value),
None => to_value(record),
})
.into_iter()
.collect(),
RelayRecord::Session(session) => changed(match current.and_then(parse::<ListenSession>) {
Some(current) => merge_listen_session(&current, session)
.ok()
.as_ref()
.and_then(to_value),
None => to_value(session),
})
.into_iter()
.collect(),
}
}
fn parse<T: DeserializeOwned>(value: &Value) -> Option<T> {
serde_json::from_value(value.clone()).ok()
}
fn to_value<T: Serialize>(value: &T) -> Option<Value> {
serde_json::to_value(value).ok()
}
/// Merges register updates into the user's relay state.
pub(crate) async fn merge_records(
pool: &sqlx::PgPool,
user_id: i64,
records: &[RelayRecord],
) -> Result<()> {
if records.is_empty() {
return Ok(());
}
let mut tx = pool.begin().await?;
// One writer per account: a merge reads, combines and writes documents.
sqlx::query(
"SELECT pg_advisory_xact_lock(hashtextextended('furumusic:podcast-relay:' || $1::text, 0))",
)
.bind(user_id)
.execute(&mut *tx)
.await?;
let mut docs = std::collections::BTreeMap::new();
for record in records {
for key in read_keys(record) {
if !docs.contains_key(&key)
&& let Some(value) = load(&mut tx, user_id, key.0, &key.1).await?
{
docs.insert(key, value);
}
}
for (key, value) in plan_merge(&docs, record) {
match &value {
Some(value) => store(&mut tx, user_id, key.0, &key.1, value).await?,
None => {
sqlx::query(
"DELETE FROM furumusic__fed_podcast_relay
WHERE user_id = $1 AND section = $2 AND record_key = $3",
)
.bind(user_id)
.bind(key.0)
.bind(&key.1)
.execute(&mut *tx)
.await?;
}
}
match value {
Some(value) => docs.insert(key, value),
None => docs.remove(&key),
};
}
}
tx.commit().await?;
Ok(())
}
async fn load(
tx: &mut sqlx::Transaction<'_, sqlx::Postgres>,
user_id: i64,
section: &str,
key: &str,
) -> Result<Option<Value>> {
Ok(sqlx::query_scalar(
"SELECT record_json FROM furumusic__fed_podcast_relay
WHERE user_id = $1 AND section = $2 AND record_key = $3",
)
.bind(user_id)
.bind(section)
.bind(key)
.fetch_optional(&mut **tx)
.await?)
}
async fn store(
tx: &mut sqlx::Transaction<'_, sqlx::Postgres>,
user_id: i64,
section: &str,
key: &str,
value: &Value,
) -> Result<()> {
sqlx::query(
"INSERT INTO furumusic__fed_podcast_relay
(user_id, section, record_key, record_json, updated_at_ms)
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (user_id, section, record_key) DO UPDATE SET
record_json = EXCLUDED.record_json,
updated_at_ms = EXCLUDED.updated_at_ms",
)
.bind(user_id)
.bind(section)
.bind(key)
.bind(value)
.bind(chrono::Utc::now().timestamp_millis())
.execute(&mut **tx)
.await?;
Ok(())
}
/// Relayed progress register of an episode, if any.
pub(crate) async fn progress_record(
pool: &sqlx::PgPool,
user_id: i64,
episode_id: &str,
) -> Result<Option<ProgressRecord>> {
let value: Option<Value> = sqlx::query_scalar(
"SELECT record_json FROM furumusic__fed_podcast_relay
WHERE user_id = $1 AND section = $2 AND record_key = $3",
)
.bind(user_id)
.bind(SECTION_PROGRESS)
.bind(episode_id)
.fetch_optional(pool)
.await?;
Ok(value.as_ref().and_then(parse))
}
/// Adds the relayed podcast registers to `snapshot`.
///
/// The sections are bounded later, per message, with the contract budget
/// (`SyncSnapshot::bound_podcast_state_to`) and stripped for peers below v4
/// (`SyncSnapshot::for_peer`).
pub(crate) async fn fill_snapshot(
pool: &sqlx::PgPool,
user_id: i64,
snapshot: &mut SyncSnapshot,
) -> Result<()> {
let rows = sqlx::query(
"SELECT section, record_json FROM furumusic__fed_podcast_relay
WHERE user_id = $1 AND section <> $2
ORDER BY section, record_key",
)
.bind(user_id)
.bind(SECTION_ALIASES)
.fetch_all(pool)
.await?;
for row in rows {
let section: String = row.get("section");
let value: Value = row.get("record_json");
fill_section(snapshot, &section, &value);
}
Ok(())
}
fn fill_section(snapshot: &mut SyncSnapshot, section: &str, value: &Value) {
match section {
SECTION_SUBSCRIPTION => snapshot.podcast_subscriptions.extend(parse(value)),
SECTION_SHARE => snapshot.podcast_shares.extend(parse(value)),
SECTION_PROGRESS => snapshot.podcast_progress.extend(parse(value)),
SECTION_SESSION => snapshot.podcast_listen_sessions.extend(parse(value)),
_ => {}
}
}
#[cfg(test)]
mod tests {
use super::*;
use music_dht::device_sync::{SyncOpPayload, SyncOpWire};
use music_dht::podcast::{EpisodeId, PodcastMeta, ProgressStatus};
use std::collections::BTreeMap;
fn feed(path: &str) -> FeedUrl {
FeedUrl::parse(&format!("https://podcasts.example/{path}")).unwrap()
}
fn meta() -> PodcastMeta {
serde_json::from_value(serde_json::json!({
"feed_url": feed("feed.xml").as_str(),
"title": "Example Cast",
"description": "Long channel description",
}))
.unwrap()
}
fn podcast() -> PodcastId {
PodcastId::from_feed_url(&feed("feed.xml"))
}
fn op(seq: i64, hlc_ms: i64, payload: SyncOpPayload) -> SyncOpWire {
SyncOpWire {
op_id: format!("tui_a:{seq}"),
origin_device_id: "tui_a".into(),
seq,
hlc_ms,
payload,
}
}
fn progress(seq: i64, generation: u64, hlc_ms: i64, position_ms: i64) -> SyncOpWire {
let podcast_id = podcast();
op(
seq,
hlc_ms,
SyncOpPayload::PodcastProgressSet {
episode_id: EpisodeId::from_guid(&podcast_id, "ep-1").unwrap(),
podcast_id,
position_ms,
status: ProgressStatus::InProgress,
generation,
session_id: format!("s{generation}"),
episode: None,
},
)
}
/// Applies records to an in-memory table with the production plan.
fn apply(state: &mut BTreeMap<DocKey, Value>, records: &[RelayRecord]) {
for record in records {
for (key, value) in plan_merge(state, record) {
match value {
Some(value) => state.insert(key, value),
None => state.remove(&key),
};
}
}
}
fn snapshot_of(state: &BTreeMap<DocKey, Value>) -> SyncSnapshot {
let mut snapshot = SyncSnapshot::default();
for ((section, _), value) in state {
fill_section(&mut snapshot, section, value);
}
snapshot
}
#[test]
fn progress_registers_follow_the_contract_in_any_order() {
// A late checkpoint of an older generation never wins, whatever its clock.
let ops = [
progress(1, 3, 9_000, 600_000),
progress(2, 4, 1_000, 10_000),
];
for order in [[0, 1], [1, 0]] {
let mut state = BTreeMap::new();
for index in order {
apply(&mut state, &[RelayRecord::from_op(&ops[index]).unwrap()]);
}
let snapshot = snapshot_of(&state);
assert_eq!(snapshot.podcast_progress.len(), 1);
assert_eq!(snapshot.podcast_progress[0].position_ms, 10_000);
assert_eq!(snapshot.podcast_progress[0].generation, 4);
}
}
#[test]
fn snapshot_sections_survive_the_relay() {
let subscribe = op(
1,
10,
SyncOpPayload::PodcastSubscriptionSet {
podcast_id: podcast(),
subscribed: true,
podcast: meta(),
feed_aliases: vec![],
generation: 1,
},
);
let share = op(
2,
11,
SyncOpPayload::PodcastShareSet {
podcast_id: podcast(),
shared: false,
generation: 1,
},
);
let mut source = BTreeMap::new();
for op in [&subscribe, &share, &progress(3, 2, 12, 5_000)] {
op.validate_podcast().unwrap();
apply(&mut source, &[RelayRecord::from_op(op).unwrap()]);
}
let mut sent = snapshot_of(&source);
sent.bound_podcast_state();
// A second relay that only saw the snapshot re-emits the same state.
let mut relay = BTreeMap::new();
apply(&mut relay, &RelayRecord::from_snapshot(&sent));
let mut relayed = snapshot_of(&relay);
relayed.bound_podcast_state();
assert_eq!(relayed, sent);
assert!(!relayed.podcast_shares[0].shared);
assert!(relayed.podcast_subscriptions[0].subscribed);
// Peers below v4 never receive the sections.
assert!(!relayed.for_peer(3).has_podcast_state());
assert!(relayed.for_peer(4).has_podcast_state());
}
#[test]
fn aliases_learned_before_the_subscription_are_merged_into_it() {
let aliases = op(
1,
10,
SyncOpPayload::PodcastFeedAliasesAdded {
podcast_id: podcast(),
feed_aliases: vec![feed("moved.xml")],
},
);
let subscribe = op(
2,
11,
SyncOpPayload::PodcastSubscriptionSet {
podcast_id: podcast(),
subscribed: true,
podcast: meta(),
feed_aliases: vec![],
generation: 1,
},
);
let mut state = BTreeMap::new();
apply(&mut state, &[RelayRecord::from_op(&aliases).unwrap()]);
apply(&mut state, &[RelayRecord::from_op(&subscribe).unwrap()]);
let snapshot = snapshot_of(&state);
assert_eq!(
snapshot.podcast_subscriptions[0].feed_urls(),
vec![feed("feed.xml"), feed("moved.xml")]
);
assert!(!state.keys().any(|(section, _)| *section == SECTION_ALIASES));
}
#[test]
fn oversized_snapshot_sections_are_ignored() {
let mut snapshot = SyncSnapshot::default();
let record = RelayRecord::from_op(&progress(1, 1, 1, 1)).unwrap();
let RelayRecord::Progress(record) = record else {
unreachable!()
};
snapshot.podcast_progress = vec![record; music_dht::podcast::MAX_SNAPSHOT_PROGRESS + 1];
assert!(RelayRecord::from_snapshot(&snapshot).is_empty());
snapshot
.podcast_progress
.truncate(music_dht::podcast::MAX_SNAPSHOT_PROGRESS);
assert_eq!(
RelayRecord::from_snapshot(&snapshot).len(),
music_dht::podcast::MAX_SNAPSHOT_PROGRESS
);
}
}
+2
View File
@@ -382,6 +382,8 @@ translations! {
player_clear: "Clear" , "Очистить";
player_remove: "Remove" , "Удалить";
player_queue_empty: "Queue is empty" , "Очередь пуста";
player_queue_podcast_unplayable: "Podcast · not playable in the web player yet", "Подкаст · пока не воспроизводится в веб-плеере";
player_queue_private_item: "Private item · hidden by its owner", "Приватный элемент · скрыт владельцем";
player_shuffle: "Shuffle" , "Перемешать";
player_repeat: "Repeat" , "Повтор";
player_volume: "Volume" , "Громкость";
+24 -2
View File
@@ -20,6 +20,7 @@ struct PlaybackStateRow {
current_track_id: Option<i64>,
position_ms: i32,
queue_json: String,
queue_items_json: Option<serde_json::Value>,
queue_position: i32,
}
@@ -738,7 +739,7 @@ async fn cleanup_playback_states(
) -> anyhow::Result<()> {
let deleted: HashSet<i64> = track_ids.iter().copied().collect();
let states: Vec<PlaybackStateRow> = sqlx::query_as(
"SELECT id, current_track_id, position_ms, queue_json, queue_position FROM furumusic__playback_state FOR UPDATE",
"SELECT id, current_track_id, position_ms, queue_json, queue_items_json, queue_position FROM furumusic__playback_state FOR UPDATE",
)
.fetch_all(&mut **transaction)
.await?;
@@ -746,6 +747,14 @@ async fn cleanup_playback_states(
for state in states {
let mut queue: Vec<i64> = serde_json::from_str(&state.queue_json).unwrap_or_default();
let original_queue = queue.clone();
let mut typed = crate::player::queue_items::StoredQueue::from_columns(
state.queue_items_json.as_ref(),
&crate::player::queue_items::LegacyColumns {
queue: original_queue.clone(),
current_track_id: state.current_track_id,
queue_position: state.queue_position,
},
);
queue.retain(|track_id| !deleted.contains(track_id));
let current_track_id = state.current_track_id.filter(|id| !deleted.contains(id));
if queue == original_queue && current_track_id == state.current_track_id {
@@ -763,16 +772,28 @@ async fn cleanup_playback_states(
.clamp(0, i32::try_from(queue.len() - 1).unwrap_or(i32::MAX))
}
});
if let Some(typed) = &mut typed {
typed.retain_library(
|track_id| !deleted.contains(&track_id),
crate::player::queue_items::LegacyColumns {
queue: queue.clone(),
current_track_id,
queue_position,
},
);
}
let position_ms = if current_track_id.is_some() {
state.position_ms
} else {
0
};
let queue_json = serde_json::to_string(&queue)?;
// The typed queue keeps its other items; a stale one is cleared.
let queue_items_json = typed.map(serde_json::to_value).transpose()?;
sqlx::query(
r#"UPDATE furumusic__playback_state
SET current_track_id = $2, position_ms = $3,
queue_json = $4, queue_position = $5
queue_json = $4, queue_position = $5, queue_items_json = $6
WHERE id = $1"#,
)
.bind(state.id)
@@ -780,6 +801,7 @@ async fn cleanup_playback_states(
.bind(position_ms)
.bind(queue_json)
.bind(queue_position)
.bind(queue_items_json)
.execute(&mut **transaction)
.await?;
}
+106
View File
@@ -2838,6 +2838,110 @@ pub mod db_migrations {
&[Operation::custom(add_import_playlist_destinations).build()];
}
// -- M0054: typed playback queue next to the legacy id list ------------
// (`m_0053` is taken by `src/user.rs` in the same app.)
// `queue_json` keeps the library track ids and is still written, so an
// older release can run against the same database. The typed value adds
// the items that are not library tracks (podcast episodes, unresolved
// federated music, Jam placeholders) with their explicit source.
#[cot::db::migrations::migration_op]
async fn add_typed_playback_queue(
ctx: migrations::MigrationContext<'_>,
) -> cot::db::Result<()> {
ctx.db
.raw(
"ALTER TABLE furumusic__playback_state
ADD COLUMN IF NOT EXISTS queue_items_json JSONB",
)
.await?;
Ok(())
}
#[cot::db::migrations::migration_op]
async fn drop_typed_playback_queue(
ctx: migrations::MigrationContext<'_>,
) -> cot::db::Result<()> {
ctx.db
.raw("ALTER TABLE furumusic__playback_state DROP COLUMN IF EXISTS queue_items_json")
.await?;
Ok(())
}
#[derive(Debug, Copy, Clone)]
pub struct M0054AddTypedPlaybackQueue;
impl migrations::Migration for M0054AddTypedPlaybackQueue {
const APP_NAME: &'static str = "furumusic";
const MIGRATION_NAME: &'static str = "m_0054_add_typed_playback_queue";
const DEPENDENCIES: &'static [migrations::MigrationDependency] =
&[migrations::MigrationDependency::migration(
"furumusic",
"m_0052_add_import_playlist_destinations",
)];
const OPERATIONS: &'static [Operation] = &[Operation::custom(add_typed_playback_queue)
.backwards(drop_typed_playback_queue)
.build()];
}
// -- M0055: opaque podcast sync relay state (device-sync protocol v4) ---
// Podcast registers received from trusted devices, kept as the shared
// contract JSON so this server can return them in its snapshots. This is
// not the podcast store: the web player has no podcast features yet.
#[cot::db::migrations::migration_op]
async fn create_fed_podcast_relay(
ctx: migrations::MigrationContext<'_>,
) -> cot::db::Result<()> {
ctx.db
.raw(
"CREATE TABLE IF NOT EXISTS furumusic__fed_podcast_relay (
user_id BIGINT NOT NULL,
section VARCHAR(16) NOT NULL,
record_key TEXT NOT NULL,
record_json JSONB NOT NULL,
updated_at_ms BIGINT NOT NULL,
PRIMARY KEY (user_id, section, record_key)
)",
)
.await?;
Ok(())
}
/// Removes the operations a 0.12.x release cannot parse: the podcast
/// kinds relayed since device-sync protocol 4. Ends with its `WHERE`
/// clause, so tests can narrow it to one user.
pub(crate) const DELETE_PODCAST_SYNC_OPS_SQL: &str =
"DELETE FROM furumusic__fed_sync_ops WHERE kind LIKE 'podcast\\_%'";
// Release 0.12.x parses every unacknowledged operation it sends to a
// peer and fails the whole batch on an unknown kind, so the podcast
// operations relayed by 0.13 must go before it runs again (see
// docs/administration.md, "Rolling back to 0.12").
#[cot::db::migrations::migration_op]
async fn drop_fed_podcast_relay(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
ctx.db.raw(DELETE_PODCAST_SYNC_OPS_SQL).await?;
ctx.db
.raw("DROP TABLE IF EXISTS furumusic__fed_podcast_relay")
.await?;
Ok(())
}
#[derive(Debug, Copy, Clone)]
pub struct M0055CreateFedPodcastRelay;
impl migrations::Migration for M0055CreateFedPodcastRelay {
const APP_NAME: &'static str = "furumusic";
const MIGRATION_NAME: &'static str = "m_0055_create_fed_podcast_relay";
const DEPENDENCIES: &'static [migrations::MigrationDependency] =
&[migrations::MigrationDependency::migration(
"furumusic",
"m_0054_add_typed_playback_queue",
)];
const OPERATIONS: &'static [Operation] = &[Operation::custom(create_fed_podcast_relay)
.backwards(drop_fed_podcast_relay)
.build()];
}
pub const MIGRATIONS: &[&SyncDynMigration] = &[
&M0006CreateMediaFile,
&M0007CreateArtist,
@@ -2881,5 +2985,7 @@ pub mod db_migrations {
&M0050CreateMetadataFixHistory,
&M0051AddListenStatisticsIndexes,
&M0052AddImportPlaylistDestinations,
&M0054AddTypedPlaybackQueue,
&M0055CreateFedPodcastRelay,
];
}
+15
View File
@@ -147,6 +147,17 @@ pub(super) struct PlaybackStateDto {
pub(super) shuffle: bool,
pub(super) repeat_mode: String,
pub(super) volume: f64,
/// Typed queue (podcast episodes and other non-library items included).
///
/// Requests send `{"kind": "library", "track_id"}` and
/// `{"kind": "external", "track": <device-sync PlaybackTrack>}` items;
/// responses return external items as browser track JSON. Clients that
/// omit it keep using `queue`, which is always written.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(super) queue_items: Option<serde_json::Value>,
/// Index of the current item in `queue_items`.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(super) queue_items_position: Option<usize>,
}
#[derive(Debug, Deserialize, JsonSchema)]
@@ -263,6 +274,10 @@ pub(super) struct PlayerDevicePlaybackStateDto {
pub(super) volume: f64,
#[serde(default)]
pub(super) updated_at_ms: i64,
/// The browser does not know the position of its current item, a podcast
/// episode it cannot play (`queue_items::POSITION_UNKNOWN_KEY`).
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub(super) position_unknown: bool,
}
#[derive(Debug, Serialize, JsonSchema)]
+494 -7
View File
@@ -29,6 +29,7 @@ use crate::youtube::{YouTubePreviewRequest, YouTubeService, YouTubeStartRequest}
mod dto;
mod helpers;
mod queries;
pub(crate) mod queue_items;
mod rows;
mod sharing;
@@ -606,7 +607,7 @@ impl PlayerDeviceHub {
target_device_id: Option<&str>,
jam_id: Option<&str>,
command: &str,
payload: serde_json::Value,
mut payload: serde_json::Value,
) -> Result<(), &'static str> {
let now = current_millis();
let mut state = self.state.lock().expect("player device hub lock");
@@ -621,6 +622,15 @@ impl PlayerDeviceHub {
let target_id = self
.jam_target_device_id_locked(&state, jam)
.ok_or("jam playback device is offline")?;
if user_id != jam.host_user_id {
let host_tracks = state
.playback_state_by_user
.get(&jam.host_user_id)
.map(|playback| playback.tracks.clone())
.unwrap_or_default();
restore_jam_command_payload(command, &mut payload, &host_tracks)?;
stamp_jam_participant_command(&mut payload);
}
(jam.host_user_id, target_id)
} else {
let target_id = match target_device_id {
@@ -1042,11 +1052,17 @@ impl PlayerDeviceHub {
})
})
.unwrap_or(user_id);
state
let playback = state
.playback_state_by_user
.get(&playback_user_id)
.cloned()
.map(|playback_state| playback_state_at(playback_state, now))
.map(|playback_state| playback_state_at(playback_state, now));
if playback_user_id == user_id {
return playback;
}
// Jam participants are outside the host's trusted devices: private
// items (podcast episodes) become opaque placeholders.
playback.map(redact_playback_state_for_jam)
}
fn jam_dtos_locked(
@@ -1457,6 +1473,7 @@ mod device_tests {
repeat_mode: "off".to_string(),
volume: 0.7,
updated_at_ms: current_millis(),
position_unknown: false,
},
);
}
@@ -1646,6 +1663,246 @@ pub struct PlayerPageTemplate {
pub youtube_downloads_enabled: bool,
}
#[cfg(test)]
mod queue_persistence_tests {
use super::*;
use music_dht::device_sync::PlaybackTrack;
fn offline_pool() -> sqlx::PgPool {
sqlx::postgres::PgPoolOptions::new()
.connect_lazy("postgres://offline@127.0.0.1:1/offline")
.unwrap()
}
fn request(queue_items: serde_json::Value, position: usize) -> PlaybackStateDto {
PlaybackStateDto {
current_track_id: Some(3),
position_ms: 1_000,
queue: vec![3, 4],
queue_position: 1,
shuffle: false,
repeat_mode: "off".into(),
volume: 0.5,
queue_items: Some(queue_items),
queue_items_position: Some(position),
}
}
#[tokio::test]
async fn podcast_items_survive_persistence_and_reload() {
let episode = PlaybackTrack::podcast_episode(queue_items::test_episode());
let browser_track = queue_items::external_track_json(&episode, 1, None);
// The browser sends `_queueItemsPayload(queue.tracks)`.
let dto = request(
serde_json::json!([
{"kind": "library", "track_id": 3},
{"kind": "external", "track": browser_track["wire_track"]},
{"kind": "library", "track_id": 4},
]),
1,
);
let stored = stored_queue_from_request(&dto).unwrap();
// Written to queue_items_json and read back with the legacy ids.
let column = serde_json::to_value(&stored).unwrap();
let row = queue_items::LegacyColumns {
queue: dto.queue.clone(),
current_track_id: dto.current_track_id,
queue_position: dto.queue_position,
};
let loaded = queue_items::StoredQueue::from_columns(Some(&column), &row).unwrap();
assert_eq!(loaded, stored);
assert_eq!(loaded.position, 1);
let items = browser_queue_items(&offline_pool(), &loaded).await.unwrap();
assert_eq!(
items[0],
serde_json::json!({"kind": "library", "track_id": 3})
);
assert_eq!(items[1]["kind"], "external");
assert_eq!(items[1]["track"]["source"]["kind"], "podcast_episode");
assert_eq!(
queue_items::wire_track_from_browser_json(&items[1]["track"]),
Some(episode)
);
}
#[test]
fn malformed_typed_queues_keep_the_legacy_ids_only() {
let dto = request(
serde_json::json!([{"kind": "external", "track": {"id": "x"}}]),
0,
);
assert!(stored_queue_from_request(&dto).is_none());
let legacy_only = PlaybackStateDto {
queue_items: None,
..request(serde_json::json!([]), 0)
};
assert!(stored_queue_from_request(&legacy_only).is_none());
// Older clients do not send the new fields.
let old: PlaybackStateDto = serde_json::from_value(serde_json::json!({
"current_track_id": 3, "position_ms": 0, "queue": [3], "queue_position": 0,
"shuffle": false, "repeat_mode": "off", "volume": 0.7,
}))
.unwrap();
assert!(old.queue_items.is_none());
assert!(!serde_json::to_string(&old).unwrap().contains("queue_items"));
}
}
#[cfg(test)]
mod jam_command_tests {
use super::*;
use music_dht::device_sync::{PRIVATE_ITEM_TITLE, PlaybackTrack};
fn library(id: i64) -> serde_json::Value {
serde_json::json!({"id": id, "title": format!("Song {id}"), "duration_seconds": 100.0})
}
fn host_tracks() -> Vec<serde_json::Value> {
let episode = PlaybackTrack::podcast_episode(queue_items::test_episode());
vec![
library(1),
queue_items::external_track_json(&episode, 1, None),
library(2),
]
}
fn check(command: &str, payload: serde_json::Value) -> Result<(), &'static str> {
let mut payload = payload;
restore_jam_command_payload(command, &mut payload, &host_tracks())
}
#[test]
fn participants_cannot_remove_or_clear_private_items() {
assert!(check("queue_remove", serde_json::json!({"index": 1})).is_err());
assert!(check("queue_clear", serde_json::json!({})).is_err());
// Music can still be removed, and private items moved.
assert!(check("queue_remove", serde_json::json!({"index": 0})).is_ok());
assert!(check("queue_remove", serde_json::json!({"index": 2})).is_ok());
assert!(
check(
"queue_move",
serde_json::json!({"from_index": 1, "to_index": 0})
)
.is_ok()
);
// The host runs `Number(index)`: other spellings of an index are refused.
for index in [
serde_json::json!("1"),
serde_json::json!(1.0),
serde_json::json!(-1),
] {
assert!(check("queue_remove", serde_json::json!({"index": index})).is_err());
}
assert!(check("queue_remove", serde_json::json!({})).is_err());
// Without private items the host queue can be cleared as before.
let mut payload = serde_json::json!({});
assert!(restore_jam_command_payload("queue_clear", &mut payload, &[library(1)]).is_ok());
}
#[test]
fn participant_commands_reach_the_host_stamped() {
let hub = PlayerDeviceHub::default();
hub.heartbeat(1, "host", None, None, None);
let jam = hub
.create_jam(1, "Host", "host", vec![(2, "Guest".to_string())])
.unwrap();
let jam_id = jam.jams[0].id.clone();
hub.heartbeat(2, "guest", None, None, None);
hub.join_jam(2, "Guest", "guest", &jam_id).unwrap();
let tracks = host_tracks();
hub.heartbeat(
1,
"host",
None,
Some(&jam_id),
Some(PlayerDevicePlaybackStateDto {
track: Some(tracks[0].clone()),
tracks,
index: 0,
position_seconds: 0.0,
duration_seconds: 100.0,
paused: false,
shuffle: false,
repeat_mode: "off".into(),
volume: 0.5,
updated_at_ms: 0,
position_unknown: false,
}),
);
// Move the episode to the end, then remove index 2: the cached host
// state still has music there, so only the host can refuse it.
for (command, payload) in [
(
"queue_move",
serde_json::json!({"from_index": 1, "to_index": 2}),
),
("queue_remove", serde_json::json!({"index": 2})),
("pause", serde_json::Value::Null),
] {
hub.enqueue_command(2, None, Some(&jam_id), command, payload)
.unwrap();
}
hub.enqueue_command(
1,
None,
Some(&jam_id),
"queue_remove",
serde_json::json!({"index": 0}),
)
.unwrap();
let commands = hub.poll(1, "host", None, Some(&jam_id), None).commands;
let stamped: Vec<bool> = commands
.iter()
.map(|command| command.payload[JAM_PARTICIPANT_KEY] == true)
.collect();
assert_eq!(stamped, [true, true, true, false]);
assert_eq!(commands[1].payload["index"], 2);
}
#[test]
fn redacted_current_episode_has_no_duration() {
let tracks = host_tracks();
let playback = PlayerDevicePlaybackStateDto {
track: Some(tracks[1].clone()),
tracks: tracks.clone(),
index: 1,
position_seconds: 1200.0,
duration_seconds: 1800.0,
paused: false,
shuffle: false,
repeat_mode: "off".into(),
volume: 0.5,
updated_at_ms: 0,
position_unknown: false,
};
let redacted = redact_playback_state_for_jam(playback.clone());
assert_eq!(redacted.duration_seconds, 0.0);
assert_eq!(
redacted.track.as_ref().unwrap()["title"],
PRIVATE_ITEM_TITLE
);
assert_eq!(redacted.position_seconds, 1200.0);
let leaked = serde_json::to_string(&redacted).unwrap();
assert!(!leaked.contains("1800") && !leaked.contains("Episode"));
// A music track keeps its duration.
let music = redact_playback_state_for_jam(PlayerDevicePlaybackStateDto {
track: Some(tracks[0].clone()),
index: 0,
duration_seconds: 100.0,
..playback.clone()
});
assert_eq!(music.duration_seconds, 100.0);
// Without `track` the current item is taken from `tracks[index]`.
let untracked = redact_playback_state_for_jam(PlayerDevicePlaybackStateDto {
track: None,
..playback
});
assert_eq!(untracked.duration_seconds, 0.0);
}
}
#[cfg(test)]
mod page_template_tests {
use super::*;
@@ -5755,6 +6012,16 @@ async fn devices_select_handler(
.and_then(normalize_device_id)
.unwrap_or_else(|| target_device_id.clone());
let previous_active_id = hub.active_device_id_for_commands(user.id);
// Refuse a handoff the target cannot receive before ownership moves.
if let Some(fed_device_id) = fed_device_id_from_virtual(&target_device_id)
&& previous_active_id.as_deref() != Some(target_device_id.as_str())
&& let Some(state) = hub.playback_state_json_for_commands(user.id)
&& let Err(err) = crate::federation::handle()
.fed_device_web_transfer_check(user.id, fed_device_id, state)
.await
{
return Ok(json_error(StatusCode::CONFLICT, &format!("{err}")));
}
let Some(response) = hub.select(user.id, &current_device_id, &target_device_id) else {
return Ok(json_error(
@@ -5992,6 +6259,158 @@ async fn fed_devices_sync_handler(
}
}
/// Host playback state as shown to Jam participants
/// (`music_dht::device_sync::redact_for_jam` over the browser queue).
fn redact_playback_state_for_jam(
mut playback: PlayerDevicePlaybackStateDto,
) -> PlayerDevicePlaybackStateDto {
let index = usize::try_from(playback.index).unwrap_or(0);
let current_is_private = playback
.track
.as_ref()
.or_else(|| playback.tracks.get(index))
.is_some_and(queue_items::browser_track_requires_podcast_support);
playback.tracks = queue_items::redact_tracks_for_jam(&playback.tracks);
if current_is_private {
// Placeholders carry no duration; the host's position is kept like
// `redact_for_jam` keeps `position_secs`.
playback.duration_seconds = 0.0;
}
if playback
.track
.as_ref()
.is_some_and(queue_items::browser_track_requires_podcast_support)
{
playback.track = playback.tracks.get(index).cloned().or_else(|| {
Some(
queue_items::redact_tracks_for_jam(std::slice::from_ref(playback.track.as_ref()?))
[0]
.clone(),
)
});
}
playback
}
/// Applies the Jam privacy rules to a participant command.
///
/// Participants cannot add podcast episodes. A full queue they send (play or
/// transfer) gets the host's private items back in place of the
/// placeholders; queues that drop, duplicate or inject private items are
/// rejected. Participants cannot remove a private item, nor clear a queue
/// that holds one; they may still move it (`queue_move`).
fn restore_jam_command_payload(
command: &str,
payload: &mut serde_json::Value,
host_tracks: &[serde_json::Value],
) -> Result<(), &'static str> {
const REJECTED: &str = "podcast episodes are private and cannot be changed in a jam";
let tracks: Vec<serde_json::Value> = payload
.get("tracks")
.and_then(serde_json::Value::as_array)
.cloned()
.unwrap_or_default();
let current = payload
.get("track")
.filter(|track| !track.is_null())
.cloned();
match command {
"queue_add_end" | "queue_add_next" => {
if tracks
.iter()
.any(queue_items::browser_track_requires_podcast_support)
{
return Err(REJECTED);
}
}
"play_track" | "play_from_index" | "transfer_state" => {
if !queue_items::jam_tracks_allowed(&tracks)
|| current.as_ref().is_some_and(|track| {
!queue_items::jam_tracks_allowed(std::slice::from_ref(track))
})
{
return Err(REJECTED);
}
if tracks.is_empty() {
if current
.as_ref()
.is_some_and(queue_items::browser_track_requires_podcast_support)
{
return Err(REJECTED);
}
return Ok(());
}
let restored = queue_items::restore_jam_tracks(host_tracks, &tracks).ok_or(REJECTED)?;
if let Some(object) = payload.as_object_mut() {
if current
.as_ref()
.is_some_and(queue_items::browser_track_requires_podcast_support)
{
let index = object
.get("index")
.and_then(serde_json::Value::as_u64)
.unwrap_or(0) as usize;
let track = restored.get(index).cloned().ok_or(REJECTED)?;
object.insert("track".to_string(), track);
}
object.insert("tracks".to_string(), serde_json::Value::Array(restored));
}
}
"queue_remove" => {
// The participant view has the host's length and order, so the
// index names the same item on the host.
let index = payload
.get("index")
.and_then(serde_json::Value::as_u64)
.and_then(|index| usize::try_from(index).ok());
let removes_private = match index {
Some(index) => host_tracks
.get(index)
.is_some_and(queue_items::browser_track_requires_podcast_support),
// The host browser runs `Number(index)`, so "1" or 1.0 would
// still name an item: only plain indexes pass a private queue.
None => host_tracks
.iter()
.any(queue_items::browser_track_requires_podcast_support),
};
if removes_private {
return Err(REJECTED);
}
}
"queue_clear"
if host_tracks
.iter()
.any(queue_items::browser_track_requires_podcast_support) =>
{
return Err(REJECTED);
}
_ => {}
}
Ok(())
}
/// Marks a Jam participant command for the host browser.
///
/// `restore_jam_command_payload` checks the command against the host state of
/// the host's last report. The host browser runs its pending commands in one
/// batch, so an earlier command (a move, an insert) can make a checked index
/// name a private item there. The host browser applies the same rules to its
/// own queue for stamped commands (`_jamParticipantCommandAllowed`).
fn stamp_jam_participant_command(payload: &mut serde_json::Value) {
if !payload.is_object() {
*payload = serde_json::json!({});
}
if let Some(object) = payload.as_object_mut() {
object.insert(
JAM_PARTICIPANT_KEY.to_string(),
serde_json::Value::Bool(true),
);
}
}
/// Command payload key set by the server on Jam participant commands.
const JAM_PARTICIPANT_KEY: &str = "jam_participant";
fn stamp_jam_queue_tracks(payload: &mut serde_json::Value, user_id: i64, user_name: &str) {
let Some(tracks) = payload
.get_mut("tracks")
@@ -6320,7 +6739,7 @@ async fn get_state_handler(
};
let state = sqlx::query_as::<_, PlaybackStateRow>(
r#"SELECT current_track_id, position_ms, queue_json, queue_position, shuffle, repeat_mode::text as repeat_mode, volume
r#"SELECT current_track_id, position_ms, queue_json, queue_items_json, queue_position, shuffle, repeat_mode::text as repeat_mode, volume
FROM furumusic__playback_state WHERE user_id = $1"#,
)
.bind(user.id)
@@ -6331,6 +6750,26 @@ async fn get_state_handler(
let dto = match state {
Some(s) => {
let queue: Vec<i64> = serde_json::from_str(&s.queue_json).unwrap_or_default();
// Prefer the typed queue while it matches the legacy columns.
let typed = queue_items::StoredQueue::from_columns(
s.queue_items_json.as_ref(),
&queue_items::LegacyColumns {
queue: queue.clone(),
current_track_id: s.current_track_id,
queue_position: s.queue_position,
},
);
let (queue_items, queue_items_position) = match typed {
Some(stored) => (
Some(
browser_queue_items(pool, &stored)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?,
),
Some(stored.position),
),
None => (None, None),
};
PlaybackStateDto {
current_track_id: s.current_track_id,
position_ms: s.position_ms,
@@ -6339,6 +6778,8 @@ async fn get_state_handler(
shuffle: s.shuffle,
repeat_mode: s.repeat_mode,
volume: s.volume,
queue_items,
queue_items_position,
}
}
None => PlaybackStateDto {
@@ -6349,12 +6790,51 @@ async fn get_state_handler(
shuffle: false,
repeat_mode: "off".to_string(),
volume: 0.7,
queue_items: None,
queue_items_position: None,
},
};
Json(dto).into_response()
}
/// Typed queue items for the browser: library ids to load, external items
/// as browser track JSON with their verbatim wire item.
async fn browser_queue_items(
pool: &sqlx::PgPool,
stored: &queue_items::StoredQueue,
) -> anyhow::Result<serde_json::Value> {
let mut items = Vec::with_capacity(stored.items.len());
for (index, item) in stored.items.iter().enumerate() {
items.push(match item {
queue_items::StoredQueueItem::Library { track_id } => {
serde_json::json!({"kind": "library", "track_id": track_id})
}
queue_items::StoredQueueItem::External { track } => serde_json::json!({
"kind": "external",
"track": crate::federation::devices::resolve_playback_track(pool, track, index).await?,
}),
});
}
Ok(serde_json::Value::Array(items))
}
/// Typed queue to persist from a state request; `None` keeps only the legacy
/// ids (older clients, malformed or oversized queues).
fn stored_queue_from_request(dto: &PlaybackStateDto) -> Option<queue_items::StoredQueue> {
let items: Vec<queue_items::StoredQueueItem> =
serde_json::from_value(dto.queue_items.clone()?).ok()?;
queue_items::StoredQueue::new(
items,
dto.queue_items_position.unwrap_or(0),
queue_items::LegacyColumns {
queue: dto.queue.clone(),
current_track_id: dto.current_track_id,
queue_position: dto.queue_position,
},
)
}
// ---------------------------------------------------------------------------
// PUT /api/player/state
// ---------------------------------------------------------------------------
@@ -6372,15 +6852,21 @@ async fn put_state_handler(
let queue_json =
serde_json::to_string(&dto.queue).map_err(|e| cot::Error::internal(e.to_string()))?;
// `queue_json` is still written so an older release keeps working.
let queue_items_json = stored_queue_from_request(&dto)
.map(serde_json::to_value)
.transpose()
.map_err(|e| cot::Error::internal(e.to_string()))?;
let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
sqlx::query(
r#"INSERT INTO furumusic__playback_state (user_id, current_track_id, position_ms, queue_json, queue_position, shuffle, repeat_mode, volume, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
r#"INSERT INTO furumusic__playback_state (user_id, current_track_id, position_ms, queue_json, queue_position, shuffle, repeat_mode, volume, updated_at, queue_items_json)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
ON CONFLICT (user_id) DO UPDATE SET
current_track_id = $2, position_ms = $3, queue_json = $4,
queue_position = $5, shuffle = $6, repeat_mode = $7, volume = $8, updated_at = $9"#,
queue_position = $5, shuffle = $6, repeat_mode = $7, volume = $8, updated_at = $9,
queue_items_json = $10"#,
)
.bind(user.id)
.bind(dto.current_track_id)
@@ -6391,6 +6877,7 @@ async fn put_state_handler(
.bind(&dto.repeat_mode)
.bind(dto.volume)
.bind(&now)
.bind(queue_items_json)
.execute(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
+701
View File
@@ -0,0 +1,701 @@
//! Lossless queue items shared by the browser player, device sync and the
//! persisted playback state.
//!
//! The browser queue holds plain track JSON objects. Library tracks of this
//! server keep their usual shape. Every other item received from a trusted
//! device (unresolved federated music, podcast episodes, Jam private
//! placeholders) becomes an *external* item: display fields for the queue UI
//! plus the verbatim device-sync DTO under [`WIRE_TRACK_KEY`] and its explicit
//! [`PlaybackSource`] under [`SOURCE_KEY`]. Converting back to the wire uses
//! the verbatim DTO, so such items survive browser -> server -> peers ->
//! server -> browser unchanged even though this web player cannot play them.
//!
//! Gating and Jam decisions are delegated to `music_dht::device_sync`; this
//! module only maps browser JSON onto the shared DTOs.
use music_dht::device_sync::{
PRIVATE_ITEM_TITLE, PlaybackCommand, PlaybackSource, PlaybackStateWire, PlaybackTrack,
jam_command_allowed, redact_for_jam, restore_jam_private_items,
};
use serde::{Deserialize, Serialize};
use serde_json::Value;
/// Browser track key holding the verbatim [`PlaybackTrack`] of an external item.
pub(crate) const WIRE_TRACK_KEY: &str = "wire_track";
/// Browser track key holding the explicit [`PlaybackSource`] of an external item.
pub(crate) const SOURCE_KEY: &str = "source";
/// Browser playback state key: `true` when the browser does not know the
/// position of its current item. That happens when it selects a podcast
/// episode it cannot play (Next, auto-advance, a click or a play command):
/// it is never told where the episode was left, and inventing 0 would
/// restart the episode for every device. The server then takes the
/// position from the episode's progress register.
pub(crate) const POSITION_UNKNOWN_KEY: &str = "position_unknown";
/// Reason shown for federated music that is not in this library.
pub(crate) const FED_UNAVAILABLE_REASON: &str = "Not available on this web player yet";
/// Reason shown for podcast episodes, which this web player cannot play yet.
pub(crate) const PODCAST_UNAVAILABLE_REASON: &str =
"Podcast episodes cannot be played on the web player yet";
/// Reason shown for Jam placeholders of someone else's private item.
pub(crate) const PRIVATE_UNAVAILABLE_REASON: &str = "Private item of the Jam host";
/// Version of the typed queue stored in `furumusic__playback_state.queue_items_json`.
pub(crate) const STORED_QUEUE_VERSION: u16 = 1;
/// Upper bound of persisted queue items; larger queues keep only `queue_json`.
pub(crate) const MAX_STORED_QUEUE_ITEMS: usize = 10_000;
/// Browser JSON for a queue item that is not a library track of this server.
///
/// `content_id` is the normalized content id of a music item, when known.
/// The `id` is a negative placeholder that is stable for the item and its
/// queue position, so the browser can tell items apart; it never refers to a
/// library track.
pub(crate) fn external_track_json(
track: &PlaybackTrack,
index: usize,
content_id: Option<&str>,
) -> Value {
let mut json = match &track.source {
Some(PlaybackSource::PodcastEpisode(episode)) => serde_json::json!({
"id": placeholder_track_id(Some(episode.episode_id.as_str()), index),
"title": episode.episode_title,
"track_number": serde_json::Value::Null,
"disc_number": serde_json::Value::Null,
"duration_seconds": episode.duration_ms.unwrap_or(0).max(0) as f64 / 1_000.0,
"artists": artist_names_to_json(std::slice::from_ref(&episode.podcast_title)),
"featured_artists": [],
"release_id": 0,
"release_title": episode.podcast_title,
"release_year": serde_json::Value::Null,
"cover_url": serde_json::Value::Null,
"stream_url": "",
"uploader_name": "Podcast",
"audio_format": episode.mime,
"content_id": serde_json::Value::Null,
"unavailable": true,
"unavailable_reason": PODCAST_UNAVAILABLE_REASON,
}),
Some(PlaybackSource::Private) => serde_json::json!({
"id": placeholder_track_id(Some("private"), index),
"title": PRIVATE_ITEM_TITLE,
"track_number": serde_json::Value::Null,
"disc_number": serde_json::Value::Null,
"duration_seconds": 0.0,
"artists": [],
"featured_artists": [],
"release_id": 0,
"release_title": "",
"release_year": serde_json::Value::Null,
"cover_url": serde_json::Value::Null,
"stream_url": "",
"uploader_name": "",
"content_id": serde_json::Value::Null,
"unavailable": true,
"unavailable_reason": PRIVATE_UNAVAILABLE_REASON,
}),
Some(PlaybackSource::Music) | None => music_placeholder_json(track, index, content_id),
};
if let Some(object) = json.as_object_mut() {
if let Some(source) = &track.source
&& let Ok(source) = serde_json::to_value(source)
{
object.insert(SOURCE_KEY.to_string(), source);
}
if let Ok(wire) = serde_json::to_value(track) {
object.insert(WIRE_TRACK_KEY.to_string(), wire);
}
}
json
}
/// Display fields of unresolved federated music (unchanged from earlier
/// releases, which had no verbatim wire item).
fn music_placeholder_json(track: &PlaybackTrack, index: usize, content_id: Option<&str>) -> Value {
let artists = if !track.artist_names.is_empty() {
track.artist_names.clone()
} else if let Some(fed) = &track.fed {
fed.artist_names.clone()
} else {
Vec::new()
};
let featured = if !track.featured_artist_names.is_empty() {
track.featured_artist_names.clone()
} else if let Some(fed) = &track.fed {
fed.featured_artist_names.clone()
} else {
Vec::new()
};
let title = track
.fed
.as_ref()
.map(|fed| fed.title.as_str())
.filter(|title| !title.trim().is_empty())
.unwrap_or(&track.title);
let release_title = track
.fed
.as_ref()
.and_then(|fed| fed.release_title.as_deref())
.filter(|title| !title.trim().is_empty())
.unwrap_or(&track.release_title);
let content_id = content_id
.map(ToString::to_string)
.or_else(|| track.content_id.clone())
.or_else(|| track.fed.as_ref().map(|fed| fed.content_id.clone()));
serde_json::json!({
"id": placeholder_track_id(content_id.as_deref(), index),
"title": title,
"track_number": track.track_number,
"disc_number": track.disc_number,
"duration_seconds": track.duration_seconds,
"artists": artist_names_to_json(&artists),
"featured_artists": artist_names_to_json(&featured),
"release_id": 0,
"release_title": release_title,
"release_year": track.release_year,
"cover_url": serde_json::Value::Null,
"stream_url": "",
"uploader_name": "Federation",
"audio_format": track.audio_format.clone(),
"audio_bitrate": track.audio_bitrate,
"audio_sample_rate": track.audio_sample_rate,
"audio_bit_depth": track.audio_bit_depth,
"file_size_bytes": track.file_size_bytes,
"content_id": content_id,
"unavailable": true,
"unavailable_reason": FED_UNAVAILABLE_REASON,
})
}
fn artist_names_to_json(names: &[String]) -> Vec<Value> {
names
.iter()
.enumerate()
.filter(|(_, name)| !name.trim().is_empty())
.map(|(index, name)| serde_json::json!({"id": -((index as i64) + 1), "name": name}))
.collect()
}
fn placeholder_track_id(seed: Option<&str>, index: usize) -> i64 {
let mut bytes = [0u8; 8];
let hash = blake3::hash(seed.unwrap_or("").as_bytes());
bytes.copy_from_slice(&hash.as_bytes()[..8]);
let value = i64::from_le_bytes(bytes).unsigned_abs() % 9_000_000_000_000;
-((value as i64) + index as i64 + 1)
}
/// The device-sync item carried by an external browser track.
///
/// Returns the verbatim [`WIRE_TRACK_KEY`] DTO when present. Otherwise a
/// browser item that only names a podcast or private [`SOURCE_KEY`] is
/// rebuilt with the shared constructors. Library tracks (and malformed
/// items) return `None` and keep the library mapping.
pub(crate) fn wire_track_from_browser_json(track: &Value) -> Option<PlaybackTrack> {
if let Some(wire) = track.get(WIRE_TRACK_KEY).filter(|wire| wire.is_object())
&& let Ok(wire) = serde_json::from_value::<PlaybackTrack>(wire.clone())
{
return Some(wire);
}
match serde_json::from_value::<PlaybackSource>(track.get(SOURCE_KEY)?.clone()).ok()? {
PlaybackSource::PodcastEpisode(episode) => Some(PlaybackTrack::podcast_episode(*episode)),
PlaybackSource::Private => Some(PlaybackTrack::private_placeholder()),
PlaybackSource::Music => None,
}
}
/// Whether a browser item is a podcast episode or a Jam placeholder.
pub(crate) fn browser_track_requires_podcast_support(track: &Value) -> bool {
wire_track_from_browser_json(track).is_some_and(|track| track.requires_podcast_support())
}
/// Wire-shaped view of browser tracks for the shared gating and Jam helpers.
///
/// External items are their verbatim DTOs. Library tracks become minimal
/// music items: the helpers only look at item sources and positions, so
/// this conversion needs no database lookups.
pub(crate) fn shadow_wire_state(tracks: &[Value], index: usize) -> PlaybackStateWire {
PlaybackStateWire {
queue: tracks
.iter()
.map(|track| wire_track_from_browser_json(track).unwrap_or_else(|| music_stub(track)))
.collect(),
queue_pos: index,
playing: false,
paused: true,
idle_since_ms: None,
position_secs: 0.0,
volume: 0,
shuffle: false,
repeat: Default::default(),
playback_rate: None,
}
}
fn music_stub(track: &Value) -> PlaybackTrack {
PlaybackTrack {
id: track.get("id").and_then(Value::as_i64).unwrap_or(0),
title: String::new(),
track_number: None,
disc_number: None,
duration_seconds: 0.0,
artist_names: Vec::new(),
featured_artist_names: Vec::new(),
release_id: 0,
release_title: String::new(),
release_year: None,
file_path: String::new(),
content_id: None,
audio_format: None,
audio_bitrate: None,
audio_sample_rate: None,
audio_bit_depth: None,
file_size_bytes: None,
play_count: 0,
fed: None,
source: None,
}
}
/// Browser tracks as shown to Jam participants.
///
/// Uses [`redact_for_jam`]: every podcast episode (and existing placeholder)
/// becomes the opaque private placeholder; music, order and position stay.
pub(crate) fn redact_tracks_for_jam(tracks: &[Value]) -> Vec<Value> {
let redacted = redact_for_jam(shadow_wire_state(tracks, 0));
tracks
.iter()
.zip(redacted.queue.iter())
.enumerate()
.map(|(index, (original, redacted))| {
if redacted.is_private_placeholder() {
external_track_json(redacted, index, None)
} else {
original.clone()
}
})
.collect()
}
/// Maps the private placeholders of a Jam participant's full queue back to
/// the host's items ([`restore_jam_private_items`]).
///
/// Returns `None` when the participant queue contains real podcast episodes
/// or drops, duplicates or injects private items; the command is then
/// rejected.
pub(crate) fn restore_jam_tracks(host: &[Value], participant: &[Value]) -> Option<Vec<Value>> {
let host_state = shadow_wire_state(host, 0);
let restored = restore_jam_private_items(&host_state, shadow_wire_state(participant, 0))?;
let mut host_private = host
.iter()
.zip(host_state.queue.iter())
.filter(|(_, wire)| wire.requires_podcast_support())
.map(|(json, _)| json);
let participant_state = shadow_wire_state(participant, 0);
let mut out = Vec::with_capacity(participant.len());
for ((json, before), after) in participant
.iter()
.zip(participant_state.queue.iter())
.zip(restored.queue.iter())
{
if before.is_private_placeholder() {
out.push(host_private.next()?.clone());
} else {
debug_assert_eq!(before, after);
out.push(json.clone());
}
}
Some(out)
}
/// Whether tracks sent by a Jam participant may enter the host queue at all
/// ([`jam_command_allowed`]): participants cannot add podcast episodes.
pub(crate) fn jam_tracks_allowed(tracks: &[Value]) -> bool {
jam_command_allowed(&PlaybackCommand::SetState {
state: shadow_wire_state(tracks, 0),
seek: false,
})
}
/// Typed playback queue persisted next to the legacy `queue_json`.
///
/// `queue_json` (a list of library track ids) is still written for rollback
/// to older releases. `legacy_queue`, `legacy_current_track_id` and
/// `legacy_queue_position` record the legacy columns written alongside this
/// value: when they no longer match the row (an older release or a
/// legacy-only writer changed the queue or moved to another track since),
/// readers ignore the typed value and fall back to the legacy columns.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub(crate) struct StoredQueue {
/// Shape version, [`STORED_QUEUE_VERSION`].
pub(crate) version: u16,
/// Index of the current item in `items`.
#[serde(default)]
pub(crate) position: usize,
/// Queue items in order.
#[serde(default)]
pub(crate) items: Vec<StoredQueueItem>,
/// `queue_json` ids written together with this value.
#[serde(default)]
pub(crate) legacy_queue: Vec<i64>,
/// `current_track_id` written together with this value.
#[serde(default)]
pub(crate) legacy_current_track_id: Option<i64>,
/// `queue_position` written together with this value (`None`: unknown,
/// the value is not used).
#[serde(default)]
pub(crate) legacy_queue_position: Option<i32>,
}
/// Legacy queue columns of a `furumusic__playback_state` row.
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub(crate) struct LegacyColumns {
/// `queue_json`: library track ids.
pub(crate) queue: Vec<i64>,
/// `current_track_id`.
pub(crate) current_track_id: Option<i64>,
/// `queue_position`.
pub(crate) queue_position: i32,
}
/// One persisted queue item.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub(crate) enum StoredQueueItem {
/// Library track of this server.
Library {
/// Local track id.
track_id: i64,
},
/// Any other item, kept verbatim with its explicit `source`.
External {
/// Device-sync queue item.
track: Box<PlaybackTrack>,
},
}
impl StoredQueue {
/// Builds the persisted value; `None` when the queue exceeds the bound.
///
/// Jam private placeholders are dropped: they stand for the Jam host's
/// items, never for items of this user's own queue.
pub(crate) fn new(
items: Vec<StoredQueueItem>,
position: usize,
legacy: LegacyColumns,
) -> Option<Self> {
if items.len() > MAX_STORED_QUEUE_ITEMS {
return None;
}
let mut stored = Self {
version: STORED_QUEUE_VERSION,
position,
items,
legacy_queue: Vec::new(),
legacy_current_track_id: None,
legacy_queue_position: None,
};
stored.retain_items(|item| match item {
StoredQueueItem::Library { .. } => true,
StoredQueueItem::External { track } => !track.is_private_placeholder(),
});
stored.set_legacy(legacy);
Some(stored)
}
/// Reads the typed column, preferring it over the legacy columns only
/// when it has a known version and was written together with exactly
/// these legacy values.
pub(crate) fn from_columns(typed: Option<&Value>, legacy: &LegacyColumns) -> Option<Self> {
let stored = serde_json::from_value::<Self>(typed?.clone()).ok()?;
(stored.version == STORED_QUEUE_VERSION
&& stored.legacy_queue == legacy.queue
&& stored.legacy_current_track_id == legacy.current_track_id
&& stored.legacy_queue_position == Some(legacy.queue_position)
&& stored.items.len() <= MAX_STORED_QUEUE_ITEMS)
.then_some(stored)
}
/// Removes library tracks rejected by `keep` and records the new legacy
/// columns. The current position follows its item, or the item after it
/// when the current item was removed.
pub(crate) fn retain_library(&mut self, keep: impl Fn(i64) -> bool, legacy: LegacyColumns) {
self.retain_items(|item| match item {
StoredQueueItem::Library { track_id } => keep(*track_id),
StoredQueueItem::External { .. } => true,
});
self.set_legacy(legacy);
}
fn retain_items(&mut self, keep: impl Fn(&StoredQueueItem) -> bool) {
let original_position = self.position;
let mut position = self.position;
let mut index = 0;
self.items.retain(|item| {
let retained = keep(item);
if !retained && index < original_position {
position = position.saturating_sub(1);
}
index += 1;
retained
});
self.position = position.min(self.items.len().saturating_sub(1));
}
fn set_legacy(&mut self, legacy: LegacyColumns) {
self.legacy_queue = legacy.queue;
self.legacy_current_track_id = legacy.current_track_id;
self.legacy_queue_position = Some(legacy.queue_position);
}
}
/// A valid podcast episode reference for tests.
#[cfg(test)]
pub(crate) fn test_episode() -> music_dht::podcast::PodcastEpisodeRef {
use music_dht::podcast::{EpisodeId, FeedUrl, PodcastEpisodeRef, PodcastId};
let feed_url = FeedUrl::parse("https://podcasts.example/feed.xml?token=Ab").unwrap();
let podcast_id = PodcastId::from_feed_url(&feed_url);
let episode_id = EpisodeId::from_guid(&podcast_id, "episode-42").unwrap();
PodcastEpisodeRef {
podcast_id,
episode_id,
feed_url,
podcast_title: "Example Cast".into(),
episode_title: "Episode 42".into(),
audio_url: "https://cdn.example/ep42.mp3".into(),
mime: Some("audio/mpeg".into()),
duration_ms: Some(1_800_000),
published_at_ms: Some(1_700_000_000_000),
season: Some(2),
episode_number: Some(42),
image_url: None,
progress_generation: Some(7),
}
}
#[cfg(test)]
mod tests {
use super::*;
use music_dht::podcast::EpisodeId;
fn episode() -> music_dht::podcast::PodcastEpisodeRef {
test_episode()
}
fn library(id: i64) -> Value {
serde_json::json!({"id": id, "title": format!("Track {id}"), "stream_url": format!("/api/player/stream/{id}")})
}
#[test]
fn podcast_item_round_trips_through_browser_json() {
let mut wire = PlaybackTrack::podcast_episode(episode());
wire.play_count = 3;
let json = external_track_json(&wire, 4, None);
assert_eq!(json["unavailable"], true);
assert_eq!(json["unavailable_reason"], PODCAST_UNAVAILABLE_REASON);
assert_eq!(json["title"], "Episode 42");
assert_eq!(json[SOURCE_KEY]["kind"], "podcast_episode");
assert!(json["id"].as_i64().unwrap() < 0);
// The browser stores and echoes the object; the item is unchanged.
let echoed: Value = serde_json::from_str(&json.to_string()).unwrap();
assert_eq!(wire_track_from_browser_json(&echoed), Some(wire));
}
#[test]
fn private_and_unresolved_music_keep_their_wire_item() {
let private = PlaybackTrack::private_placeholder();
let json = external_track_json(&private, 0, None);
assert_eq!(json["title"], PRIVATE_ITEM_TITLE);
assert_eq!(json[SOURCE_KEY]["kind"], "private");
assert_eq!(wire_track_from_browser_json(&json), Some(private));
let mut music = PlaybackTrack::private_placeholder();
music.source = None;
music.title = "Remote song".into();
music.content_id = Some(format!("b3:{}", "a".repeat(64)));
let json = external_track_json(&music, 1, music.content_id.as_deref());
assert!(json.get(SOURCE_KEY).is_none());
assert_eq!(json["unavailable_reason"], FED_UNAVAILABLE_REASON);
assert_eq!(wire_track_from_browser_json(&json), Some(music));
}
#[test]
fn library_tracks_are_not_external() {
assert_eq!(wire_track_from_browser_json(&library(5)), None);
let mut music_source = library(6);
music_source[SOURCE_KEY] = serde_json::json!({"kind": "music"});
assert_eq!(wire_track_from_browser_json(&music_source), None);
}
#[test]
fn source_only_items_use_shared_constructors() {
let json = serde_json::json!({
"id": -1,
SOURCE_KEY: serde_json::to_value(PlaybackSource::PodcastEpisode(Box::new(episode()))).unwrap(),
});
assert_eq!(
wire_track_from_browser_json(&json),
Some(PlaybackTrack::podcast_episode(episode()))
);
// A malformed verbatim item falls back to the explicit source.
let mut tampered = json.clone();
tampered[WIRE_TRACK_KEY] = serde_json::json!({"id": "x"});
assert_eq!(
wire_track_from_browser_json(&tampered),
Some(PlaybackTrack::podcast_episode(episode()))
);
}
#[test]
fn jam_redaction_hides_episodes_and_restores_them_in_order() {
let first = external_track_json(&PlaybackTrack::podcast_episode(episode()), 1, None);
let mut other = episode();
other.episode_title = "Episode 43".into();
other.episode_id = EpisodeId::from_guid(&other.podcast_id, "episode-43").unwrap();
let second = external_track_json(&PlaybackTrack::podcast_episode(other), 3, None);
let host = vec![library(1), first.clone(), library(2), second.clone()];
let redacted = redact_tracks_for_jam(&host);
assert_eq!(redacted[0], host[0]);
assert_eq!(redacted[1]["title"], PRIVATE_ITEM_TITLE);
let leaked = serde_json::to_string(&redacted).unwrap();
assert!(!leaked.contains("Episode 4") && !leaked.contains("podcasts.example"));
assert!(!leaked.contains("cdn.example") && !leaked.contains("Example Cast"));
// The participant reorders music and moves a placeholder.
let participant = vec![
redacted[3].clone(),
library(2),
redacted[1].clone(),
library(1),
];
let restored = restore_jam_tracks(&host, &participant).unwrap();
assert_eq!(
restored,
vec![first.clone(), library(2), second, library(1)]
);
// Dropping, duplicating or injecting private items is rejected.
assert!(restore_jam_tracks(&host, &[library(1), redacted[1].clone()]).is_none());
assert!(restore_jam_tracks(&host, &[first.clone(), redacted[1].clone()]).is_none());
assert!(!jam_tracks_allowed(std::slice::from_ref(&first)));
assert!(jam_tracks_allowed(&[library(9)]));
}
fn legacy(queue: &[i64], current_track_id: Option<i64>, queue_position: i32) -> LegacyColumns {
LegacyColumns {
queue: queue.to_vec(),
current_track_id,
queue_position,
}
}
#[test]
fn stored_queue_prefers_typed_value_only_while_legacy_ids_match() {
let items = vec![
StoredQueueItem::Library { track_id: 3 },
StoredQueueItem::External {
track: Box::new(PlaybackTrack::podcast_episode(episode())),
},
StoredQueueItem::Library { track_id: 4 },
];
// The episode is current: the browser wrote its placeholder id.
let written = legacy(&[3, -11, 4], Some(-11), 1);
let stored = StoredQueue::new(items, 1, written.clone()).unwrap();
let value = serde_json::to_value(&stored).unwrap();
assert_eq!(value["version"], 1);
assert_eq!(value["items"][1]["kind"], "external");
assert_eq!(
value["items"][1]["track"]["source"]["kind"],
"podcast_episode"
);
assert_eq!(
StoredQueue::from_columns(Some(&value), &written),
Some(stored.clone())
);
// A rollback release rewrote queue_json: fall back to it.
assert_eq!(
StoredQueue::from_columns(Some(&value), &legacy(&[3, 4], Some(4), 1)),
None
);
// A rollback release kept the ids but moved to another track (Next
// or a click): the typed position is stale, fall back as well.
assert_eq!(
StoredQueue::from_columns(Some(&value), &legacy(&[3, -11, 4], Some(4), 2)),
None
);
assert_eq!(
StoredQueue::from_columns(Some(&value), &legacy(&[3, -11, 4], Some(-11), 0)),
None
);
// Values without the recorded current item are not trusted.
let mut unknown = value.clone();
unknown
.as_object_mut()
.unwrap()
.remove("legacy_queue_position");
assert_eq!(StoredQueue::from_columns(Some(&unknown), &written), None);
let mut future = value.clone();
future["version"] = serde_json::json!(2);
assert_eq!(StoredQueue::from_columns(Some(&future), &written), None);
assert_eq!(StoredQueue::from_columns(None, &written), None);
}
#[test]
fn stored_queue_never_keeps_jam_placeholders() {
let items = vec![
StoredQueueItem::Library { track_id: 3 },
StoredQueueItem::External {
track: Box::new(PlaybackTrack::private_placeholder()),
},
StoredQueueItem::External {
track: Box::new(PlaybackTrack::podcast_episode(episode())),
},
StoredQueueItem::Library { track_id: 4 },
];
let stored = StoredQueue::new(items.clone(), 3, legacy(&[3, 4], Some(4), 1)).unwrap();
assert_eq!(
stored.items,
vec![items[0].clone(), items[2].clone(), items[3].clone()]
);
assert_eq!(stored.position, 2);
// A current placeholder hands the position to the next item.
let stored = StoredQueue::new(items.clone(), 1, legacy(&[3, 4], None, 0)).unwrap();
assert_eq!(stored.position, 1);
assert_eq!(stored.items[1], items[2]);
}
#[test]
fn stored_queue_cleanup_keeps_external_items_and_position() {
let items = vec![
StoredQueueItem::Library { track_id: 3 },
StoredQueueItem::External {
track: Box::new(PlaybackTrack::podcast_episode(episode())),
},
StoredQueueItem::Library { track_id: 4 },
];
let mut stored = StoredQueue::new(items.clone(), 1, legacy(&[3, 4], None, 0)).unwrap();
stored.retain_library(|id| id != 3, legacy(&[4], None, 0));
assert_eq!(stored.items, items[1..].to_vec());
assert_eq!(stored.position, 0);
assert_eq!(stored.legacy_queue, vec![4]);
// The cleanup's new legacy columns are what readers compare with.
let value = serde_json::to_value(&stored).unwrap();
assert_eq!(
StoredQueue::from_columns(Some(&value), &legacy(&[4], None, 0)),
Some(stored)
);
let mut current_removed =
StoredQueue::new(items.clone(), 2, legacy(&[3, 4], Some(4), 1)).unwrap();
current_removed.retain_library(|id| id != 4, legacy(&[3], None, 0));
assert_eq!(current_removed.position, 1);
assert!(
StoredQueue::new(
vec![items[0].clone(); MAX_STORED_QUEUE_ITEMS + 1],
0,
LegacyColumns::default()
)
.is_none()
);
}
}
+1
View File
@@ -65,6 +65,7 @@ pub(super) struct PlaybackStateRow {
pub(super) current_track_id: Option<i64>,
pub(super) position_ms: i32,
pub(super) queue_json: String,
pub(super) queue_items_json: Option<serde_json::Value>,
pub(super) queue_position: i32,
pub(super) shuffle: bool,
pub(super) repeat_mode: String,
+315 -9
View File
@@ -64,6 +64,8 @@ const T = {
lastfmDisconnectFailed: "{{ t.player_lastfm_disconnect_failed }}",
download: "{{ t.track_download }}",
shareUnavailable: "{{ t.share_unavailable }}",
queuePodcastUnplayable: "{{ t.player_queue_podcast_unplayable }}",
queuePrivateItem: "{{ t.player_queue_private_item }}",
searchSimilarTo: "{{ t.player_search_similar_to }}",
findSimilar: "{{ t.player_find_similar }}",
similarityFailed: "{{ t.player_similarity_failed }}",
@@ -755,6 +757,9 @@ document.addEventListener('alpine:init', () => {
_listenedSeconds: 0,
_lastAudioTime: 0,
_localSourceTrackId: null,
// The current item is one this player cannot play and nobody told it
// that item's position (see _showUnplayableQueueItem).
_positionUnknown: false,
_remoteExecuting: false,
_remoteStateBaseTime: 0,
_remoteStateReceivedAt: 0,
@@ -772,6 +777,9 @@ document.addEventListener('alpine:init', () => {
});
audio.addEventListener('timeupdate', () => {
// Unloading the audio for an unplayable item fires a late
// timeupdate at 0; keep that item's handed-off position.
if (!this._currentItemHasLocalAudio()) return;
this.currentTime = audio.currentTime;
this.duration = audio.duration || 0;
this.progress = this.duration > 0 ? (this.currentTime / this.duration) * 100 : 0;
@@ -857,6 +865,7 @@ document.addEventListener('alpine:init', () => {
playQueueIndex(idx) {
const queue = Alpine.store('queue');
if (!queue || idx < 0 || idx >= queue.tracks.length) return;
const previousIndex = queue.currentIndex;
queue.currentIndex = idx;
const track = queue.tracks[idx];
if (track?.federation_pending && track?._federationTrack) {
@@ -880,6 +889,24 @@ document.addEventListener('alpine:init', () => {
}));
return;
}
if (this._isUnplayableQueueItem(track)) {
// Podcast episodes stay in the queue; this player skips them.
const step = idx >= previousIndex ? 1 : -1;
let playable = this._playableQueueIndex(queue.tracks, idx, step);
if (playable < 0 && (this.repeatMode === 'all' || this.shuffle)) {
// Wrap around like the queue itself does.
playable = this._playableQueueIndex(queue.tracks, step > 0 ? 0 : queue.tracks.length - 1, step);
}
if (playable < 0) {
// Staying on the current item keeps its position; any
// other item's position is unknown here, never 0.
this._showUnplayableQueueItem(track, track === this.currentTrack ? this._knownPosition() : null);
return;
}
queue.currentIndex = playable;
this._playLocal(queue.tracks[playable]);
return;
}
this._playLocal(track);
},
@@ -900,7 +927,13 @@ document.addEventListener('alpine:init', () => {
},
_playLocal(track, options = {}) {
if (this._isUnplayableQueueItem(track)) {
this._recordHistory('replaced');
this._showUnplayableQueueItem(track, options.position_seconds);
return;
}
this._recordHistory('replaced');
this._positionUnknown = false;
this.currentTrack = track;
this._historyTrack = track;
this._prefetchedQueueKey = null;
@@ -957,9 +990,31 @@ document.addEventListener('alpine:init', () => {
this._sendRemote('resume');
return;
}
if (this._isUnplayableQueueItem(this.currentTrack)) {
// Not next(): with repeat "one" it would resume this item again.
this._skipUnplayableCurrentItem();
return;
}
audio.play().catch(() => {});
},
_skipUnplayableCurrentItem() {
const queue = Alpine.store('queue');
const tracks = queue?.tracks || [];
let idx = this._playableQueueIndex(tracks, Number(queue?.currentIndex ?? -1) + 1, 1);
if (idx < 0 && this.repeatMode === 'all') idx = this._playableQueueIndex(tracks, 0, 1);
if (idx < 0) {
this._showUnplayableQueueItem(this.currentTrack, this._knownPosition());
return;
}
this.playQueueIndex(idx);
},
_knownPosition() {
// The current item's position, or null when this player was never told it.
return this._positionUnknown ? null : this.currentTime;
},
toggle() {
if (!this.currentTrack) return;
if (this.isPlaying) { this.pause(); }
@@ -980,6 +1035,11 @@ document.addEventListener('alpine:init', () => {
this._sendRemote('seek', { time: nextTime });
return;
}
if (this._isUnplayableQueueItem(this.currentTrack)) {
// Nothing is loaded in <audio>: the seek sets the item's position.
this._showUnplayableQueueItem(this.currentTrack, nextTime);
return;
}
audio.currentTime = nextTime;
this._lastAudioTime = audio.currentTime || 0;
},
@@ -987,7 +1047,7 @@ document.addEventListener('alpine:init', () => {
seekRelative(delta) {
if (!this.currentTrack) return;
const duration = this.duration || audio.duration || 0;
const current = this._shouldSendRemote() ? this.currentTime : audio.currentTime;
const current = this._shouldSendRemote() || this._isUnplayableQueueItem(this.currentTrack) ? this.currentTime : audio.currentTime;
const max = duration > 0 ? duration : Number.MAX_SAFE_INTEGER;
this.seek(Math.max(0, Math.min(max, current + delta)));
},
@@ -1037,7 +1097,8 @@ document.addEventListener('alpine:init', () => {
this._recordHistory('skipped');
let nextIdx;
if (this.repeatMode === 'one') {
// Repeat "one" cannot repeat an item this player cannot play.
if (this.repeatMode === 'one' && !this._isUnplayableQueueItem(this.currentTrack)) {
this.seek(0);
this._historyRecorded = false;
this._resetPlaybackTracking();
@@ -1064,7 +1125,10 @@ document.addEventListener('alpine:init', () => {
this._sendRemote('prev');
return;
}
if (this.currentTime > 3) {
// An item this player cannot play is not playing here, so there
// is nothing to restart: Prev goes to the previous item.
const restartable = !this._isUnplayableQueueItem(this.currentTrack);
if (restartable && this.currentTime > 3) {
this.seek(0);
return;
}
@@ -1076,7 +1140,7 @@ document.addEventListener('alpine:init', () => {
if (this.repeatMode === 'all') {
prevIdx = queue.tracks.length - 1;
} else {
this.seek(0);
if (restartable) this.seek(0);
return;
}
}
@@ -1211,11 +1275,19 @@ document.addEventListener('alpine:init', () => {
const queue = Alpine.store('queue');
const track = this.currentTrack || queue?.tracks?.[queue.currentIndex] || null;
if (!track && (!queue || queue.tracks.length === 0)) return null;
return this._remotePlaybackPayload(track, {
position_seconds: audio.currentTime || this.currentTime || 0,
// <audio> holds an older track while an unplayable item is current.
const position = this._currentItemHasLocalAudio(track)
? (audio.currentTime || this.currentTime || 0)
: (this.currentTime || 0);
const payload = this._remotePlaybackPayload(track, {
position_seconds: position,
duration_seconds: this._trackDuration(),
paused: !this.isPlaying,
});
// The server fills the episode's resume position from its progress
// register instead of handing 0 to the next device.
if (this._positionUnknown && !this._currentItemHasLocalAudio(track)) payload.position_unknown = true;
return payload;
},
_mirrorRemoteTrack(track, playing, positionSeconds = null) {
@@ -1276,6 +1348,11 @@ document.addEventListener('alpine:init', () => {
this._remoteStateBaseTime = desiredTime;
this._remoteStateReceivedAt = Date.now();
if (this._isUnplayableQueueItem(track)) {
this._showUnplayableQueueItem(track, state.position_unknown ? null : desiredTime);
this._updateMediaSession();
return;
}
if (this._localSourceTrackId !== track.id) {
this._playLocal(track, {
position_seconds: desiredTime,
@@ -1321,6 +1398,9 @@ document.addEventListener('alpine:init', () => {
if (!command || !command.command) return;
const payload = command.payload || {};
const queue = Alpine.store('queue');
// The server stamps Jam participant commands. It checks them against
// the host state it saw last; this queue is the one they change.
if (payload.jam_participant === true && !this._jamParticipantCommandAllowed(command.command, payload, queue)) return;
this._remoteExecuting = true;
try {
if (typeof payload.shuffle === 'boolean') this.shuffle = payload.shuffle;
@@ -1335,7 +1415,13 @@ document.addEventListener('alpine:init', () => {
const track = payload.track || queue.tracks[queue.currentIndex];
if (track?.unavailable || (track && !track.stream_url)) {
this._applyRemotePlaybackState({ ...payload, track, paused: true });
this._pauseLocal();
// This device is now active, so _applyRemotePlaybackState
// does not set the time: keep the handed-off position as
// the item's position and unload the previous audio.
// Play commands start an item from 0, which for an
// episode means "its resume position", unknown here.
const known = command.command === 'transfer_state' && payload.position_unknown !== true;
this._showUnplayableQueueItem(track, known ? payload.position_seconds : null);
} else if (track) {
this._playLocal(track, payload);
}
@@ -1386,13 +1472,168 @@ document.addEventListener('alpine:init', () => {
navigator.mediaSession.setActionHandler('seekto', (d) => { if (d.seekTime != null) this.seek(d.seekTime); });
},
_queueItemSourceKind(track) {
return track?.source?.kind || track?.wire_track?.source?.kind || 'music';
},
_isUnplayableQueueItem(track) {
const kind = this._queueItemSourceKind(track);
return kind === 'podcast_episode' || kind === 'private';
},
_unplayableQueueLabel(track) {
const kind = this._queueItemSourceKind(track);
if (kind === 'podcast_episode') return T.queuePodcastUnplayable;
if (kind === 'private') return T.queuePrivateItem;
return '';
},
_playableQueueIndex(tracks, start, step = 1) {
const count = Array.isArray(tracks) ? tracks.length : 0;
for (let index = start; index >= 0 && index < count; index += step) {
if (!this._isUnplayableQueueItem(tracks[index])) return index;
}
return -1;
},
_currentItemHasLocalAudio(track = this.currentTrack) {
// Whether <audio> can hold this item: podcast episodes, private
// items and unresolved federation items are never loaded.
return !!track && !track.unavailable && !!track.stream_url && !this._isUnplayableQueueItem(track);
},
_showUnplayableQueueItem(track, positionSeconds = null) {
// `positionSeconds` null: nobody told this player where the item
// was left (it only knows positions from handoffs and seeks).
this._positionUnknown = positionSeconds == null;
// Unload the previous source so a later play() cannot resume it.
audio.pause();
audio.removeAttribute('src');
audio.load();
this.isPlaying = false;
this.currentTrack = track;
this._historyTrack = null;
this._localSourceTrackId = track?.id ?? null;
this.duration = Number(track?.duration_seconds || 0);
// Keep the item's position (handoff, restore) so it is reported back unchanged.
let position = Math.max(0, Number(positionSeconds || 0));
if (!Number.isFinite(position)) position = 0;
if (this.duration > 0) position = Math.min(position, this.duration);
this.currentTime = position;
this._remoteStateBaseTime = position;
this._remoteStateReceivedAt = Date.now();
this.progress = this.duration > 0 ? (position / this.duration) * 100 : 0;
Alpine.store('queue')?.syncCurrentIndexToTrack(track);
},
_jamParticipantCommandAllowed(command, payload, queue) {
// Jam participants cannot remove, clear away, add or bring back the
// host's private items (podcast episodes). Commands run in a batch,
// so an index the server checked can name another item by now.
const tracks = queue?.tracks || [];
const isPrivate = track => this._isUnplayableQueueItem(track);
if (command === 'queue_remove') {
const index = Number(payload.index);
if (!Number.isInteger(index)) return !tracks.some(isPrivate);
return !isPrivate(tracks[index]);
}
if (command === 'queue_clear') return !tracks.some(isPrivate);
if (command === 'queue_add_end' || command === 'queue_add_next') {
return !(Array.isArray(payload.tracks) ? payload.tracks : []).some(isPrivate);
}
if (command === 'play_track' || command === 'play_from_index' || command === 'transfer_state') {
const incoming = Array.isArray(payload.tracks) ? payload.tracks.filter(Boolean) : [];
if (incoming.length === 0) return !isPrivate(payload.track);
// A full queue replaces this one: it must hold exactly the private
// items this queue holds now (none dropped, repeated or added).
const key = track => {
const source = track?.source || track?.wire_track?.source || {};
return `${source.kind || ''}:${source.episode_id || ''}`;
};
const counts = list => {
const result = new Map();
list.filter(isPrivate).forEach(track => result.set(key(track), (result.get(key(track)) || 0) + 1));
return result;
};
const mine = counts(tracks);
const theirs = counts(incoming);
return mine.size === theirs.size && [...theirs].every(([item, count]) => mine.get(item) === count);
}
return true;
},
_dropJamPlaceholders() {
// A Jam guest's queue shows the host's private items as placeholders.
// They stand for someone else's items and never become this user's
// own queue (persisted, relayed to their devices) after the Jam.
const queue = Alpine.store('queue');
if (!queue) return;
const isPlaceholder = track => this._queueItemSourceKind(track) === 'private';
const tracks = Array.isArray(queue.tracks) ? queue.tracks : [];
if (!tracks.some(isPlaceholder) && !isPlaceholder(this.currentTrack)) return;
const currentIndex = Math.max(0, Number(queue.currentIndex || 0));
const kept = tracks.filter(track => !isPlaceholder(track));
let index = kept.indexOf(tracks[currentIndex]);
// A removed current item is followed by the next item that stays.
if (index < 0) index = tracks.slice(0, currentIndex).filter(track => !isPlaceholder(track)).length;
queue.tracks = kept;
queue.currentIndex = Math.max(0, Math.min(index, kept.length - 1));
if (!isPlaceholder(this.currentTrack)) return;
const next = kept[queue.currentIndex] || null;
if (next) {
this._playLocal(next, { paused: true });
return;
}
this._pauseLocal();
audio.removeAttribute('src');
audio.load();
this.currentTrack = null;
this._historyTrack = null;
this._localSourceTrackId = null;
this._positionUnknown = false;
this.currentTime = 0;
this.duration = 0;
this.progress = 0;
},
_queueItemsPayload(tracks) {
// Library tracks by id; everything else verbatim with its source.
return (tracks || []).map(track => {
if (track?.wire_track) return { kind: 'external', track: track.wire_track };
const id = Number(track?.id);
if (Number.isInteger(id) && id > 0 && !track?.federation_pending) {
return { kind: 'library', track_id: id };
}
return null;
});
},
_restoredQueueTracks(items, libraryTracks) {
const byId = new Map((libraryTracks || []).map(track => [track.id, track]));
const tracks = [];
const positions = [];
(items || []).forEach((item, index) => {
const track = item?.kind === 'external' ? item.track : byId.get(item?.track_id);
if (!track) return;
positions[index] = tracks.length;
tracks.push(track);
});
return { tracks, positions };
},
_buildStatePayload() {
const queue = Alpine.store('queue');
const localQueue = queue.tracks.filter(track => Number.isInteger(Number(track.id)));
const currentLocalId = this.currentTrack && Number.isInteger(Number(this.currentTrack.id))
? Number(this.currentTrack.id)
: null;
const typedItems = this._queueItemsPayload(queue.tracks);
const currentItemIndex = Math.max(0, Math.min(Number(queue.currentIndex || 0), queue.tracks.length - 1));
const queueItems = typedItems.filter(Boolean);
const queueItemsPosition = typedItems.slice(0, currentItemIndex).filter(Boolean).length;
return {
queue_items: queueItems,
queue_items_position: queueItemsPosition,
current_track_id: currentLocalId,
position_ms: Math.floor(this.currentTime * 1000),
queue: localQueue.map(track => Number(track.id)),
@@ -1436,6 +1677,56 @@ document.addEventListener('alpine:init', () => {
this.repeatMode = state.repeat_mode || 'off';
this._setVolumeLocal(typeof state.volume === 'number' ? state.volume : 0.7);
// Typed queue: library tracks by id plus external items
// (podcast episodes and other items kept with their source).
if (Array.isArray(state.queue_items) && state.queue_items.length > 0) {
try {
const ids = state.queue_items.filter(item => item?.kind === 'library').map(item => item.track_id);
let libraryTracks = [];
if (ids.length > 0) {
const tracksRes = await fetch('/api/player/tracks-by-ids', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ ids }),
});
if (tracksRes.ok) libraryTracks = await tracksRes.json();
}
const restored = this._restoredQueueTracks(state.queue_items, libraryTracks);
if (restored.tracks.length > 0) {
const queue = Alpine.store('queue');
queue.tracks = restored.tracks;
const wanted = Number(state.queue_items_position || 0);
let idx = restored.positions[wanted];
if (idx == null) idx = restored.positions.slice(wanted).find(value => value != null);
if (idx == null) idx = restored.tracks.length - 1;
queue.currentIndex = idx;
const currentTrack = restored.tracks[idx];
if (this._isUnplayableQueueItem(currentTrack)) {
// A saved 0 is treated as unknown: the server then
// uses the episode's progress register.
this._showUnplayableQueueItem(currentTrack, state.position_ms ? state.position_ms / 1000 : null);
} else if (currentTrack) {
this.currentTrack = currentTrack;
this._historyTrack = currentTrack;
this._localSourceTrackId = currentTrack.id;
this._historyRecorded = false;
this._resetPlaybackTracking();
audio.src = currentTrack.stream_url;
const seekMs = state.position_ms || 0;
if (seekMs > 0) {
const onLoaded = () => {
audio.currentTime = seekMs / 1000;
audio.removeEventListener('loadedmetadata', onLoaded);
};
audio.addEventListener('loadedmetadata', onLoaded);
}
this._updateMediaSession();
}
return;
}
} catch {}
}
// Restore queue if there are track IDs
if (state.queue && state.queue.length > 0) {
try {
@@ -1605,6 +1896,7 @@ document.addEventListener('alpine:init', () => {
fedInviteInput: '',
fedBusy: false,
fedError: '',
selectError: '',
remoteHintVisible: false,
remoteHintDeviceName: '',
_remoteHintShown: false,
@@ -1700,6 +1992,7 @@ document.addEventListener('alpine:init', () => {
_apply(data) {
const previousJamId = this.currentJamId;
const wasControllingJam = this.isControllingRemoteJam();
this.activeDeviceId = data.active_device_id || null;
this.devices = Array.isArray(data.devices) ? data.devices : [];
this.jams = Array.isArray(data.jams) ? data.jams : [];
@@ -1717,6 +2010,9 @@ document.addEventListener('alpine:init', () => {
if (!this.isActive() && !this.shouldPlayJamLocally()) {
Alpine.store('player')?._pauseLocal();
}
if (wasControllingJam && !this.isControllingRemoteJam()) {
Alpine.store('player')?._dropJamPlaceholders();
}
this._maybeShowRemoteHint();
},
@@ -2008,7 +2304,12 @@ document.addEventListener('alpine:init', () => {
current_device_id: this.id,
}),
});
if (!res.ok) return;
if (!res.ok) {
// For example: the target device needs an update to receive podcast episodes.
this.selectError = res.status === 409 ? await this._errorText(res) : '';
return;
}
this.selectError = '';
const data = await res.json();
this._apply(data);
this.open = false;
@@ -2212,11 +2513,13 @@ document.addEventListener('alpine:init', () => {
},
clearJamSelection() {
const wasControllingJam = this.isControllingRemoteJam();
this.currentJamId = null;
this.jamPanelOpen = false;
this.jamPanelJamId = null;
this._setJamLocalPlayback(false, { pauseLocal: true });
sessionStorage.removeItem('furu_player_jam_id');
if (wasControllingJam) Alpine.store('player')?._dropJamPlaceholders();
},
});
@@ -2330,7 +2633,10 @@ document.addEventListener('alpine:init', () => {
playFromIndex(idx) {
if (idx < 0 || idx >= this.tracks.length) return;
Alpine.store('player').playQueueIndex(idx);
const player = Alpine.store('player');
// A device playing the audio elsewhere may support the item.
if (player._isUnplayableQueueItem(this.tracks[idx]) && !player._shouldSendRemote()) return;
player.playQueueIndex(idx);
},
remove(idx) {
+9 -1
View File
@@ -1521,7 +1521,8 @@
<template x-for="item in $store.queue.displayItems()" :key="item.key">
<div class="queue-track"
:data-queue-index="item.index"
:class="{ active: item.state === 'current', current: item.state === 'current', played: item.state === 'played', dragging: $store.queue._dragIdx === item.index, synthetic: item.synthetic, 'foreign-jam-track': $store.queue.isForeignJamTrack(item.track) }"
:class="{ active: item.state === 'current', current: item.state === 'current', played: item.state === 'played', dragging: $store.queue._dragIdx === item.index, synthetic: item.synthetic, 'foreign-jam-track': $store.queue.isForeignJamTrack(item.track), unplayable: $store.player._isUnplayableQueueItem(item.track) }"
:title="$store.player._unplayableQueueLabel(item.track) || null"
:style="$store.queue.isForeignJamTrack(item.track) ? $store.queue.contributorStyle(item.track) : ''"
@click="item.index >= 0 ? $store.queue.playFromIndex(item.index) : $store.player.play(item.track)"
:draggable="!item.synthetic"
@@ -1574,6 +1575,10 @@
</div>
<div class="queue-track-info">
<div class="queue-track-title" x-text="item.track.title"></div>
<div class="queue-track-unplayable"
x-show="$store.player._isUnplayableQueueItem(item.track)"
x-cloak
x-text="$store.player._unplayableQueueLabel(item.track)"></div>
<div class="queue-track-artist">
<template x-for="(artist, artistIdx) in $store.library.trackArtistLinks(item.track)" :key="artist.label + '-' + artist.id + '-' + artistIdx">
<span>
@@ -1800,6 +1805,9 @@
<span>Trusted federation devices</span>
</div>
</template>
<template x-if="$store.devices.selectError">
<div class="fed-device-error device-select-error" role="alert" x-text="$store.devices.selectError"></div>
</template>
<template x-for="device in $store.devices.playbackFedDevices()" :key="device.id">
<button data-member-only class="device-row federation-device-row"
:class="{ active: device.is_active }"
+15
View File
@@ -1440,6 +1440,17 @@ button.user-stat:hover {
.queue-track.current .queue-track-title { color: var(--accent); }
.queue-track.played .queue-track-title { color: var(--text-subdued); }
.queue-track.unplayable .queue-track-title,
.queue-track.unplayable .queue-track-cover { opacity: 0.55; }
.queue-track-unplayable {
font-size: 11px;
color: var(--text-subdued);
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.queue-track-artist {
font-size: 11px;
color: var(--text-subdued);
@@ -2065,6 +2076,10 @@ button.user-stat:hover {
color: #ffb2b2;
}
.device-select-error {
padding: 6px 12px;
}
.fed-device-row {
min-height: 32px;
display: grid;
+377
View File
@@ -0,0 +1,377 @@
const assert = require('node:assert/strict');
const {readFileSync} = require('node:fs');
const {test} = require('node:test');
const vm = require('node:vm');
const template = readFileSync(`${__dirname}/../templates/player/scripts.html`, 'utf8');
// Queue items received from trusted devices that this player cannot play.
const podcast = {
id: -11, title: 'Episode 42', unavailable: true, stream_url: '',
source: {kind: 'podcast_episode', episode_id: 'ep1:x'},
wire_track: {id: 0, title: 'Episode 42', source: {kind: 'podcast_episode', episode_id: 'ep1:x'}},
};
const privateItem = {
id: -12, title: 'Private item', unavailable: true, stream_url: '',
source: {kind: 'private'}, wire_track: {id: 0, title: 'Private item', source: {kind: 'private'}},
};
const remoteMusic = {id: -13, title: 'Remote', unavailable: true, stream_url: '', wire_track: {id: 4, title: 'Remote'}};
const song = id => ({id, title: `Song ${id}`, stream_url: `/api/player/stream/${id}`});
function player(queue) {
// Exercise the production methods with audio and store stubs.
const methods = template.slice(
template.indexOf(' _queueItemSourceKind(track)'),
template.indexOf(' _saveState()'),
);
const audio = {paused: false, src: 'old', pause() { this.paused = true; }, removeAttribute(name) { if (name === 'src') this.src = ''; }, load() {}};
const stores = {queue: Object.assign({syncCurrentIndexToTrack() {}}, queue)};
const context = vm.createContext({
audio, T: {queuePodcastUnplayable: 'Podcast · not playable', queuePrivateItem: 'Private item · hidden'},
Alpine: {store: name => stores[name]},
});
vm.runInContext('this.methods = {' + methods + '};', context);
return Object.assign(context.methods, {audio, currentTrack: null, currentTime: 0, volume: 0.5, shuffle: false, repeatMode: 'off'});
}
test('podcast and private items are labelled and never played locally', () => {
const p = player({tracks: [], currentIndex: 0});
assert.equal(p._isUnplayableQueueItem(podcast), true);
assert.equal(p._isUnplayableQueueItem(privateItem), true);
assert.equal(p._isUnplayableQueueItem(remoteMusic), false);
assert.equal(p._isUnplayableQueueItem(song(1)), false);
assert.equal(p._unplayableQueueLabel(podcast), 'Podcast · not playable');
assert.equal(p._unplayableQueueLabel(privateItem), 'Private item · hidden');
assert.equal(p._unplayableQueueLabel(song(1)), '');
// A browser item that only carries the verbatim wire item is recognised too.
assert.equal(p._isUnplayableQueueItem({id: -1, wire_track: podcast.wire_track}), true);
});
test('skipping finds the next playable item in the direction of travel', () => {
const p = player({tracks: [], currentIndex: 0});
const tracks = [song(1), podcast, privateItem, song(2)];
assert.equal(p._playableQueueIndex(tracks, 1, 1), 3);
assert.equal(p._playableQueueIndex(tracks, 2, -1), 0);
assert.equal(p._playableQueueIndex([podcast], 0, 1), -1);
});
test('showing an unplayable item stops and unloads the previous audio', () => {
const p = player({tracks: [podcast], currentIndex: 0});
p.isPlaying = true;
p._showUnplayableQueueItem(podcast);
assert.equal(p.audio.paused, true);
assert.equal(p.audio.src, '');
assert.equal(p.isPlaying, false);
assert.equal(p.currentTrack, podcast);
assert.equal(p._historyTrack, null);
});
test('persisted queue keeps external items verbatim and in order', () => {
const tracks = [song(1), podcast, remoteMusic, {id: 'pending', federation_pending: true}, song(2)];
const p = player({tracks, currentIndex: 4});
p.currentTrack = tracks[4];
p.currentTime = 12.3;
const state = p._buildStatePayload();
assert.deepEqual(JSON.parse(JSON.stringify(state.queue_items)), [
{kind: 'library', track_id: 1},
{kind: 'external', track: podcast.wire_track},
{kind: 'external', track: remoteMusic.wire_track},
{kind: 'library', track_id: 2},
]);
// The pending federation entry is not persisted, as before.
assert.equal(state.queue_items_position, 3);
// The legacy id list is unchanged for rollback.
assert.deepEqual(JSON.parse(JSON.stringify(state.queue)), [1, -11, -13, 2]);
assert.equal(state.current_track_id, 2);
});
test('restoring merges library tracks and external items', () => {
const p = player({tracks: [], currentIndex: 0});
const restored = p._restoredQueueTracks([
{kind: 'library', track_id: 1},
{kind: 'external', track: podcast},
{kind: 'library', track_id: 99},
{kind: 'library', track_id: 2},
], [song(2), song(1)]);
assert.deepEqual(Array.from(restored.tracks, track => track.id), [1, -11, 2]);
assert.equal(restored.positions[3], 2);
assert.equal(restored.positions[2], undefined);
});
// Production methods by name, for flows that span several of them.
function method(name) {
const start = template.indexOf(`\n ${name}(`);
assert.ok(start >= 0, `method ${name} not found`);
const end = template.indexOf('\n },\n', start);
return template.slice(start + 1, end + 11);
}
function activePlayer(queueTracks, currentIndex, audioState = {}, options = {}) {
// The browser as the active (local) playback device.
const names = [
'_executeRemoteCommand', '_applyRemotePlaybackState', '_tickRemoteProgress',
'_devicePlaybackStatePayload', '_remotePlaybackPayload', '_trackDuration',
'_pauseLocal', '_playLocal', 'resume', 'next', 'prev', 'playQueueIndex', 'seek',
'_skipUnplayableCurrentItem', '_knownPosition', '_currentItemHasLocalAudio',
'_showUnplayableQueueItem', '_syncLocalPlaybackState',
'_queueItemSourceKind', '_isUnplayableQueueItem', '_playableQueueIndex',
'_jamParticipantCommandAllowed', '_dropJamPlaceholders',
];
const audio = Object.assign({
paused: true, currentTime: 0, duration: NaN, src: '',
played: [],
pause() { this.paused = true; },
play() { this.paused = false; this.played.push(this.src); return Promise.resolve(); },
removeAttribute(name) { if (name === 'src') this.src = ''; },
load() { this.currentTime = 0; },
addEventListener() {}, removeEventListener() {},
}, audioState);
const queue = {
tracks: queueTracks, currentIndex,
_tracksWithJamDefaults: tracks => tracks,
syncCurrentIndexToTrack(track) {
const index = this.tracks.indexOf(track);
if (index >= 0) this.currentIndex = index;
},
// Simplified local queue edits, as the host applies remote commands.
_removeLocal(index) { if (index >= 0 && index < this.tracks.length) this.tracks.splice(index, 1); },
_moveTrackLocal(from, to) { this.tracks.splice(to, 0, this.tracks.splice(from, 1)[0]); },
_clearLocal() { this.tracks = []; },
_addToEndLocal(tracks) { this.tracks.push(...tracks); },
};
const stores = {queue, devices: {heartbeat() {}}};
const context = vm.createContext({audio, Alpine: {store: name => stores[name]}});
if (options.random != null) vm.runInContext(`Math.random = () => ${options.random};`, context);
vm.runInContext('this.methods = {' + names.map(method).join('\n') + '};', context);
return Object.assign(context.methods, {
audio, queue,
currentTrack: queueTracks[currentIndex] || null, currentTime: 0, duration: 0, progress: 0,
isPlaying: false, shuffle: false, repeatMode: 'off', volume: 0.5,
_remoteStateBaseTime: 0, _remoteStateReceivedAt: 0,
_isLocalPlaybackDevice: () => true, _shouldSendRemote: () => false,
_shouldMirrorRemoteLocally: () => false,
_setVolumeLocal(v) { this.volume = v; }, _updateMediaSession() {}, _saveState() {},
_recordHistory() {}, _resetPlaybackTracking() {}, _mirrorRemoteTrack() {},
});
}
const episode = Object.assign({}, podcast, {duration_seconds: 1800});
test('handoff of a podcast episode keeps its position for the next handoff', () => {
for (const audioTime of [95, 0]) {
// <audio> still holds a music track (95 s) or the page is fresh (0 s).
const p = activePlayer([song(1)], 0, {currentTime: audioTime, src: '/api/player/stream/1'});
p._executeRemoteCommand({command: 'transfer_state', payload: {
tracks: [song(1), episode], index: 1, track: episode,
position_seconds: 1200, duration_seconds: 1800, paused: false,
}});
assert.equal(p.currentTrack, episode);
assert.equal(p.currentTime, 1200);
assert.equal(p.isPlaying, false);
assert.equal(p.audio.src, '', 'the previous track is unloaded');
const reported = p._devicePlaybackStatePayload();
assert.equal(reported.position_seconds, 1200);
assert.equal(reported.position_unknown, undefined, 'a handed-off position is known');
assert.equal(reported.index, 1);
assert.equal(reported.paused, true);
}
});
test('library tracks still report the audio position', () => {
const p = activePlayer([song(1)], 0, {currentTime: 42, src: '/api/player/stream/1'});
p.currentTime = 40;
assert.equal(p._devicePlaybackStatePayload().position_seconds, 42);
});
test('resume on an unplayable item skips it, also with repeat one', () => {
for (const repeatMode of ['one', 'off', 'all']) {
const p = activePlayer([podcast], 0);
p.repeatMode = repeatMode;
p.currentTime = 30;
p.resume();
p.next();
assert.equal(p.currentTrack, podcast);
assert.equal(p.isPlaying, false);
assert.equal(p.currentTime, 30, 'the item keeps its position');
assert.deepEqual(p.audio.played, []);
}
const p = activePlayer([song(1), podcast, song(2)], 1);
p.repeatMode = 'one';
p.resume();
assert.equal(p.currentTrack.id, 2);
assert.deepEqual(p.audio.played, ['/api/player/stream/2']);
// Repeat all wraps around to the first playable item.
const wrap = activePlayer([song(1), podcast], 1);
wrap.repeatMode = 'all';
wrap.resume();
assert.equal(wrap.currentTrack.id, 1);
});
test('an episode reached without its position reports it as unknown, never as 0', () => {
// Next from the last music track lands on a trailing episode.
const p = activePlayer([song(1), episode], 0, {currentTime: 200, src: '/api/player/stream/1'});
p.isPlaying = true;
p.currentTime = 200;
p.next();
assert.equal(p.currentTrack, episode);
assert.equal(p.isPlaying, false);
let reported = p._devicePlaybackStatePayload();
assert.equal(reported.index, 1);
assert.equal(reported.position_unknown, true);
// Still unknown after Play finds nothing to skip to.
p.resume();
assert.equal(p._devicePlaybackStatePayload().position_unknown, true);
// A seek is an explicit position.
p.seek(600);
reported = p._devicePlaybackStatePayload();
assert.equal(reported.position_seconds, 600);
assert.equal(reported.position_unknown, undefined);
// Music never reports the flag.
p.playQueueIndex(0);
assert.equal(p.currentTrack.id, 1);
assert.equal(p._devicePlaybackStatePayload().position_unknown, undefined);
// Another browser or a Jam guest plays the episode row (position 0 sent).
const remote = activePlayer([song(1), episode], 0, {currentTime: 30, src: '/api/player/stream/1'});
remote._executeRemoteCommand({command: 'play_from_index', payload: {
tracks: [song(1), episode], index: 1, track: episode, position_seconds: 0, paused: false,
}});
assert.equal(remote.currentTrack, episode);
assert.equal(remote._devicePlaybackStatePayload().position_unknown, true);
// A transfer passes on what the previous device did not know.
const relay = activePlayer([song(1)], 0);
relay._executeRemoteCommand({command: 'transfer_state', payload: {
tracks: [song(1), episode], index: 1, track: episode, position_seconds: 0,
position_unknown: true, paused: true,
}});
assert.equal(relay._devicePlaybackStatePayload().position_unknown, true);
// A mirrored state with a known position keeps it.
const mirror = activePlayer([song(1), episode], 0);
mirror._syncLocalPlaybackState({tracks: [song(1), episode], index: 1, track: episode, position_seconds: 900, paused: true});
assert.equal(mirror._devicePlaybackStatePayload().position_seconds, 900);
assert.equal(mirror._devicePlaybackStatePayload().position_unknown, undefined);
});
test('repeat all and shuffle continue past a trailing unplayable item', () => {
const wrap = activePlayer([song(1), episode], 0, {currentTime: 200, src: '/api/player/stream/1'});
wrap.repeatMode = 'all';
wrap.isPlaying = true;
wrap.next();
assert.equal(wrap.currentTrack.id, 1);
assert.equal(wrap.queue.currentIndex, 0);
assert.deepEqual(wrap.audio.played, ['/api/player/stream/1']);
// Shuffle picks the episode (index 1 of 3) and continues with music
// (searching towards the pick from the current item).
const shuffled = activePlayer([song(1), episode, song(2)], 2, {src: '/api/player/stream/2'}, {random: 0.5});
shuffled.shuffle = true;
shuffled.next();
assert.equal(shuffled.currentTrack.id, 1);
assert.equal(shuffled.isPlaying, false, 'the stub audio does not fire play events');
assert.deepEqual(shuffled.audio.played, ['/api/player/stream/1']);
// A trailing episode picked by shuffle wraps to the first playable item.
const trailing = activePlayer([song(1), song(2), episode], 1, {src: '/api/player/stream/2'}, {random: 0.9});
trailing.shuffle = true;
trailing.next();
assert.equal(trailing.currentTrack.id, 1);
// Without repeat the queue ends on the episode, as before.
const stop = activePlayer([song(1), episode], 0, {src: '/api/player/stream/1'});
stop.next();
assert.equal(stop.currentTrack, episode);
assert.equal(stop.isPlaying, false);
});
test('prev and seek work on a handed-off episode', () => {
const p = activePlayer([song(1), song(3)], 0, {currentTime: 95, src: '/api/player/stream/1'});
p._executeRemoteCommand({command: 'transfer_state', payload: {
tracks: [song(1), episode], index: 1, track: episode,
position_seconds: 1200, duration_seconds: 1800, paused: false,
}});
// Seeking moves the episode's own position (nothing is loaded in <audio>).
p.seek(1500);
assert.equal(p.currentTime, 1500);
assert.equal(p._devicePlaybackStatePayload().position_seconds, 1500);
// Prev goes to the previous item instead of restarting the episode.
p.prev();
assert.equal(p.currentTrack.id, 1);
assert.deepEqual(p.audio.played, ['/api/player/stream/1']);
// At the start of the queue Prev leaves the episode and its position alone.
const first = activePlayer([episode, song(1)], 0);
first._executeRemoteCommand({command: 'transfer_state', payload: {
tracks: [episode, song(1)], index: 0, track: episode, position_seconds: 1200, paused: true,
}});
first.prev();
assert.equal(first.currentTrack, episode);
assert.equal(first.currentTime, 1200);
});
test('the Jam host keeps its private items against stale participant commands', () => {
const a = song(1);
const b = song(2);
const p = activePlayer([a, episode, b], 0, {src: '/api/player/stream/1'});
// One poll batch: the server checked index 2 against the old order [A, P, B].
for (const command of [
{command: 'queue_move', payload: {from_index: 1, to_index: 2, jam_participant: true}},
{command: 'queue_remove', payload: {index: 2, jam_participant: true}},
]) p._executeRemoteCommand(command);
assert.deepEqual(p.queue.tracks, [a, b, episode]);
p._executeRemoteCommand({command: 'queue_clear', payload: {jam_participant: true}});
assert.equal(p.queue.tracks.length, 3);
p._executeRemoteCommand({command: 'queue_add_end', payload: {tracks: [privateItem], jam_participant: true}});
assert.equal(p.queue.tracks.length, 3);
// A full queue from a stale view brings back nothing the host removed.
p._executeRemoteCommand({command: 'play_from_index', payload: {
tracks: [a, episode, episode, b], index: 0, track: a, jam_participant: true,
}});
assert.deepEqual(p.queue.tracks, [a, b, episode]);
p._executeRemoteCommand({command: 'play_from_index', payload: {
tracks: [a, b], index: 0, track: a, jam_participant: true,
}});
assert.deepEqual(p.queue.tracks, [a, b, episode]);
// Music is still theirs to change, and the host's own commands are not limited.
p._executeRemoteCommand({command: 'queue_remove', payload: {index: 0, jam_participant: true}});
assert.deepEqual(p.queue.tracks, [b, episode]);
p._executeRemoteCommand({command: 'play_from_index', payload: {
tracks: [episode, b], index: 1, track: b, jam_participant: true,
}});
assert.deepEqual(p.queue.tracks, [episode, b]);
p._executeRemoteCommand({command: 'queue_remove', payload: {index: 0}});
assert.deepEqual(p.queue.tracks, [b]);
});
test('leaving a Jam drops the host placeholders from the guest queue', () => {
const placeholder = Object.assign({}, privateItem);
const p = activePlayer([song(1), placeholder, song(2)], 1);
p.currentTrack = placeholder;
p._dropJamPlaceholders();
assert.deepEqual(Array.from(p.queue.tracks, track => track.id), [1, 2]);
// The current placeholder hands over to the next item, paused.
assert.equal(p.queue.currentIndex, 1);
assert.equal(p.currentTrack.id, 2);
assert.equal(p.isPlaying, false);
assert.deepEqual(p.audio.played, []);
const music = activePlayer([song(1), placeholder, song(2)], 2);
music._dropJamPlaceholders();
assert.equal(music.queue.currentIndex, 1);
assert.equal(music.currentTrack.id, 2);
const only = activePlayer([placeholder], 0);
only._dropJamPlaceholders();
assert.deepEqual(only.queue.tracks, []);
assert.equal(only.currentTrack, null);
// The guest's own podcast episodes stay.
const own = activePlayer([episode, song(1)], 0);
own._dropJamPlaceholders();
assert.equal(own.queue.tracks.length, 2);
});
test('the devices store drops placeholders when the guest stops controlling a Jam', () => {
const start = template.indexOf('\n _apply(data) {');
const apply = template.slice(start, template.indexOf('\n },\n', start));
assert.match(apply, /const wasControllingJam = this\.isControllingRemoteJam\(\);/);
assert.match(apply, /if \(wasControllingJam && !this\.isControllingRemoteJam\(\)\) \{\s*Alpine\.store\('player'\)\?\._dropJamPlaceholders\(\);/);
const clear = template.slice(template.indexOf('\n clearJamSelection() {'));
assert.match(clear.slice(0, clear.indexOf('\n },\n')), /if \(wasControllingJam\) Alpine\.store\('player'\)\?\._dropJamPlaceholders\(\);/);
});