From 75c67026aca38cb9e26cd1ed83bbcef7a40bc420 Mon Sep 17 00:00:00 2001 From: Sanapach Date: Thu, 19 Nov 2026 16:58:21 +0200 Subject: [PATCH 01/73] 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 --- Cargo.lock | 6 +----- Cargo.toml | 2 +- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 68a93ca..c9caabf 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1843,8 +1843,6 @@ dependencies = [ [[package]] name = "federation-net" version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "01e5c2e6e5af020dc202d4924125ef57719aa21f8d2567e2d943914386bc8980" dependencies = [ "blake3", "data-encoding", @@ -3900,9 +3898,7 @@ 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" dependencies = [ "async-trait", "blake3", diff --git a/Cargo.toml b/Cargo.toml index bbc8624..47a7fb7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -56,4 +56,4 @@ 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" -- 2.54.0 From b558cf381e0938ec9f3649e3c7dc84c8523a3f93 Mon Sep 17 00:00:00 2001 From: Sanapach Date: Thu, 19 Nov 2026 16:58:29 +0200 Subject: [PATCH 02/73] 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 --- src/admin/metadata_fix.rs | 19 +- src/federation/devices.rs | 1118 +++++++---------- .../devices/fixtures/v3_hello.golden.json | 1 + src/federation/devices/gating_tests.rs | 416 ++++++ src/federation/devices/interop_tests.rs | 4 +- src/federation/devices/postgres_tests.rs | 328 +++++ src/federation/devices/wire_compat_tests.rs | 524 ++++++++ src/federation/mod.rs | 13 + src/federation/podcast_relay.rs | 557 ++++++++ src/i18n/phrases.rs | 2 + src/library_cleanup.rs | 15 +- src/music/mod.rs | 95 ++ src/player/dto.rs | 11 + src/player/mod.rs | 267 +++- src/player/queue_items.rs | 587 +++++++++ src/player/rows.rs | 1 + templates/player/scripts.html | 159 ++- templates/player/shell.html | 10 +- templates/player/styles.html | 15 + tests/player_queue_sources.test.cjs | 98 ++ 20 files changed, 3587 insertions(+), 653 deletions(-) create mode 100644 src/federation/devices/fixtures/v3_hello.golden.json create mode 100644 src/federation/devices/gating_tests.rs create mode 100644 src/federation/devices/postgres_tests.rs create mode 100644 src/federation/devices/wire_compat_tests.rs create mode 100644 src/federation/podcast_relay.rs create mode 100644 src/player/queue_items.rs create mode 100644 tests/player_queue_sources.test.cjs diff --git a/src/admin/metadata_fix.rs b/src/admin/metadata_fix.rs index 80c1b3b..81644e5 100644 --- a/src/admin/metadata_fix.rs +++ b/src/admin/metadata_fix.rs @@ -1438,18 +1438,22 @@ async fn delete_entities( } } // Playback queues contain local IDs rather than foreign keys. - let states: Vec<(i64, Option, String)> = sqlx::query_as( - "SELECT id,current_track_id,queue_json FROM furumusic__playback_state FOR UPDATE", + let states: Vec<(i64, Option, String, Option)> = sqlx::query_as( + "SELECT id,current_track_id,queue_json,queue_items_json 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) in states { let mut queue: Vec = 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(), + &queue, + ); let before: String = sqlx::query_scalar( "SELECT to_jsonb(t)::text FROM furumusic__playback_state t WHERE id=$1", ) @@ -1457,12 +1461,16 @@ async fn delete_entities( .fetch_one(&mut *conn) .await?; queue.retain(|id| !deleted.tracks.contains(id)); + if let Some(typed) = &mut typed { + typed.retain_library(|id| !deleted.tracks.contains(&id), queue.clone()); + } + let queue_items_json = typed.map(serde_json::to_value).transpose()?; let current = current.filter(|id| !deleted.tracks.contains(id)); 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?; + 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::(&before)?]), @@ -1502,6 +1510,7 @@ async fn restore_deleted(conn: &mut PgConnection, archived: &[ArchivedRows]) -> &[ "current_track_id", "queue_json", + "queue_items_json", "queue_position", "position_ms", ] diff --git a/src/federation/devices.rs b/src/federation/devices.rs index 125aa4f..1e2d174 100644 --- a/src/federation/devices.rs +++ b/src/federation/devices.rs @@ -1,40 +1,67 @@ //! Personal Fed Clients for the web player. //! //! The web service has one iroh endpoint, but each user owns one virtual -//! fed-device inside that endpoint. This module speaks the same JSON-lines -//! protocol as the TUI clients on `furumi/sync/1` and maps operations into -//! user-scoped Postgres state. +//! fed-device inside that endpoint. This module speaks the shared +//! `music_dht::device_sync` JSON-lines protocol of the TUI clients on +//! `furumi/sync/2` and maps operations into user-scoped Postgres state. +//! +//! The wire types are the shared definitions; there are no local copies. +//! Device-sync protocol v4 (podcasts) is announced because this adapter +//! keeps every v4 element it receives: podcast operations stay in the +//! generic operation log, podcast snapshot sections are merged into +//! [`super::podcast_relay`], and queue items keep their explicit +//! `PlaybackTrack.source` through the browser bridge +//! ([`crate::player::queue_items`]). Everything sent to a peer is gated by +//! the version that peer reported itself. -use music_dht::playback::{ - Announcement, Checkpoint, CommandStamp, Config as PlaybackConfig, Engine, -}; +use music_dht::playback::{Announcement, Checkpoint, Config as PlaybackConfig, Engine}; use std::collections::BTreeMap; -use std::str::FromStr; use std::sync::Arc; use std::time::Duration; use anyhow::{Context, Result}; -use music_dht::device_sync::{ListenEndReason, ListenEvent, ListenTrackMetadata}; +use music_dht::device_sync::{ + DEVICE_SYNC_PROTOCOL_VERSION, DeviceProfileWire, InviteWire, ListenEndReason, ListenEvent, + ListenTrackMetadata, PlaybackCommand, PlaybackRepeat, PlaybackSnapshot, PlaybackStateWire, + PlaybackTrack, SnapshotLike, SnapshotLikeTombstone, SnapshotPlaylist, SnapshotPlaylistItem, + SnapshotPlaylistItemTombstone, SnapshotPlaylistTombstone, SyncOpPayload, SyncOpWire, + SyncSnapshot, SyncedFedTrack, WireMessage, encode_invite, hash_secret, op_allowed_for_peer, + parse_invite, playback_allowed_for_peer, playback_command_allowed_from_peer, + podcast_snapshot_budget, profile_protocol_version, random_hex, relayed_protocol_version, + supports_listen_history, supports_podcasts, ticket_endpoint_id, +}; use music_dht::{ByteStream, MusicDhtService, NetworkId, PeerTicket, SecretKey, StreamAcceptor}; -use serde::{Deserialize, Serialize}; +use serde::Serialize; use sqlx::Row; -use tokio::io::{AsyncRead, AsyncReadExt}; use crate::player::PlayerDeviceHub; +use crate::player::queue_items; +use super::podcast_relay::{self, RelayRecord}; use super::{TransportStats, record_stream_transport}; pub const SYNC_ALPN: &[u8] = b"furumi/sync/2"; const CLIENT_VERSION: &str = env!("CARGO_PKG_VERSION"); -const PROTOCOL_VERSION: u16 = 3; +/// Device-sync protocol version announced by this server's virtual devices. +/// +/// Version 4 is announced only because podcast operations, podcast snapshot +/// sections and podcast queue items are kept and relayed losslessly (see +/// the module documentation). Review that support before following a newer +/// shared protocol version. +const PROTOCOL_VERSION: u16 = 4; +const _: () = assert!( + PROTOCOL_VERSION == DEVICE_SYNC_PROTOCOL_VERSION, + "review web device-sync support before announcing a new protocol version" +); +/// Lowest protocol version of a peer that speaks `furumi/sync/2`. +const SYNC_V2_PROTOCOL_VERSION: u16 = 2; const INVITE_TTL_MS: i64 = 10 * 60 * 1000; const PAIRING_WAIT_MS: i64 = 5 * 60 * 1000; const PAIRING_RETRY_DELAY: Duration = Duration::from_secs(1); const RESPONSE_DRAIN_TIMEOUT: Duration = Duration::from_secs(2); const DEVICE_SYNC_INTERVAL: Duration = Duration::from_secs(2); const LOCAL_SEED_RECHECK_MS: i64 = 60 * 1000; -const MAX_LINE: usize = 8 * 1024 * 1024; /// Playback commands carry queue state but are useful only briefly and only /// to their addressed device. They must not inflate a new peer's catch-up. const PLAYBACK_COMMAND_TTL_MS: i64 = 5 * 60 * 1_000; @@ -94,319 +121,6 @@ struct StoredDevice { endpoint_ticket: String, } -#[derive(Debug, Clone, Serialize, Deserialize)] -struct InviteWire { - v: u16, - #[serde(rename = "t")] - ticket: String, - #[serde(rename = "d")] - device_id: String, - #[serde(rename = "i")] - invite_id: String, - #[serde(rename = "s")] - secret: String, - #[serde(rename = "e")] - expires_at_ms: i64, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -struct DeviceProfileWire { - device_id: String, - name: String, - client_version: String, - protocol_version: u16, - endpoint_id: String, - endpoint_ticket: String, - #[serde(default)] - revoked: bool, - #[serde(default)] - revoke_cutoff_seq: Option, - #[serde(default)] - updated_at_ms: i64, -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -struct SyncedFedTrack { - item_id: String, - owner: String, - title: String, - #[serde(default)] - artist_names: Vec, - #[serde(default)] - featured_artist_names: Vec, - year: Option, - duration_seconds: Option, - content_id: String, - release_title: Option, - track_number: Option, - disc_number: Option, -} - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -struct PlaybackTrack { - id: i64, - title: String, - track_number: Option, - disc_number: Option, - duration_seconds: f64, - #[serde(default)] - artist_names: Vec, - #[serde(default)] - featured_artist_names: Vec, - release_id: i64, - release_title: String, - release_year: Option, - #[serde(default)] - file_path: String, - content_id: Option, - audio_format: Option, - audio_bitrate: Option, - audio_sample_rate: Option, - audio_bit_depth: Option, - file_size_bytes: Option, - #[serde(default)] - play_count: i64, - #[serde(default)] - fed: Option, -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)] -#[serde(rename_all = "snake_case")] -enum PlaybackRepeat { - #[default] - Off, - One, - All, -} - -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -struct PlaybackStateWire { - #[serde(default)] - queue: Vec, - #[serde(default)] - queue_pos: usize, - playing: bool, - paused: bool, - #[serde(default)] - idle_since_ms: Option, - position_secs: f64, - #[serde(default)] - volume: u8, - shuffle: bool, - repeat: PlaybackRepeat, -} - -type PlaybackSnapshot = music_dht::playback::Snapshot; -type PlaybackCommand = music_dht::playback::Command; - -#[derive(Debug, Clone, Serialize, Deserialize)] -struct SyncOpWire { - op_id: String, - origin_device_id: String, - seq: i64, - hlc_ms: i64, - payload: SyncOpPayload, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -#[serde(tag = "kind", rename_all = "snake_case")] -enum SyncOpPayload { - TrackLikeSet { - content_id: String, - liked: bool, - #[serde(default)] - fed: Option, - }, - 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, - }, - 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, - }, - ListenRecorded { - event: ListenEvent, - }, -} - -impl SyncOpPayload { - fn is_tombstone(&self) -> bool { - matches!( - self, - SyncOpPayload::TrackLikeSet { liked: false, .. } - | SyncOpPayload::PlaylistDeleted { .. } - | SyncOpPayload::PlaylistTrackRemoved { .. } - | SyncOpPayload::DeviceRevoked { .. } - ) - } -} - -#[derive(Debug, Clone, Default, Serialize, Deserialize)] -struct SyncSnapshot { - #[serde(default)] - likes: Vec, - #[serde(default)] - unlikes: Vec, - #[serde(default)] - playlists: Vec, - #[serde(default)] - deleted_playlists: Vec, - #[serde(default)] - removed_playlist_items: Vec, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -struct SnapshotLike { - content_id: String, - hlc_ms: i64, - op_id: String, - #[serde(default)] - fed: Option, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -struct SnapshotLikeTombstone { - content_id: String, - hlc_ms: i64, - op_id: String, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -struct SnapshotPlaylist { - playlist_id: String, - title: String, - hlc_ms: i64, - op_id: String, - #[serde(default)] - items: Vec, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -struct SnapshotPlaylistTombstone { - playlist_id: String, - hlc_ms: i64, - op_id: String, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -struct SnapshotPlaylistItem { - content_id: String, - position: i64, - hlc_ms: i64, - op_id: String, - #[serde(default)] - fed: Option, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -struct SnapshotPlaylistItemTombstone { - playlist_id: String, - content_id: String, - hlc_ms: i64, - op_id: String, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -#[serde(tag = "type", rename_all = "snake_case")] -enum WireMessage { - PairRequest { - invite_id: String, - secret: String, - profile: DeviceProfileWire, - #[serde(default)] - group_id: Option, - #[serde(default)] - group_active_devices: usize, - #[serde(default)] - devices: Vec, - vector: BTreeMap, - ops: Vec, - snapshot: SyncSnapshot, - #[serde(default)] - playback: Option, - }, - PairResponse { - accepted: bool, - #[serde(default)] - pending: bool, - #[serde(default)] - error: Option, - #[serde(default)] - group_id: Option, - #[serde(default)] - profile: Option, - #[serde(default)] - devices: Vec, - #[serde(default)] - vector: BTreeMap, - #[serde(default)] - ops: Vec, - #[serde(default)] - snapshot: SyncSnapshot, - #[serde(default)] - playback: Option, - }, - Hello { - group_id: String, - profile: DeviceProfileWire, - devices: Vec, - vector: BTreeMap, - ops: Vec, - snapshot: SyncSnapshot, - #[serde(default)] - playback: Option, - }, - SyncResponse { - accepted: bool, - #[serde(default)] - error: Option, - #[serde(default)] - devices: Vec, - #[serde(default)] - vector: BTreeMap, - #[serde(default)] - ops: Vec, - #[serde(default)] - snapshot: SyncSnapshot, - #[serde(default)] - playback: Option, - }, -} - enum PairAttempt { Accepted(String), Pending, @@ -443,8 +157,9 @@ pub async fn create_invite( invite_id, secret, expires_at_ms, + protocol_version: Some(PROTOCOL_VERSION), }; - encode_invite(&payload) + Ok(encode_invite(&payload)?) } pub async fn connect_invite( @@ -528,11 +243,13 @@ pub async fn answer_pairing( if let Some(row) = pending { let device_id: String = row.get("device_id"); enforce_single_user_binding(pool, user_id, &device_id).await?; + // The pending row has no version; the requester reports it again in + // the PairRequest it repeats until the answer arrives. let profile = DeviceProfileWire { device_id, name: row.get("name"), client_version: row.get("client_version"), - protocol_version: PROTOCOL_VERSION, + protocol_version: music_dht::device_sync::UNREPORTED_PROTOCOL_VERSION, endpoint_id: row.get("endpoint_id"), endpoint_ticket: row.get("endpoint_ticket"), revoked: false, @@ -552,9 +269,16 @@ pub async fn answer_pairing( } let devices_json: String = row.get("requester_group_devices_json"); let devices: Vec = serde_json::from_str(&devices_json)?; - apply_device_profiles(pool, user_id, &devices).await?; + apply_device_profiles(pool, user_id, &devices, Some(&profile.device_id)).await?; } - apply_device_profile(pool, user_id, &profile, true).await?; + apply_device_profile( + pool, + user_id, + &profile, + VersionReport::SelfReported(None), + true, + ) + .await?; record_local_op( pool, user_id, @@ -1179,9 +903,13 @@ async fn try_connect_invite( let profile = own_profile(pool, user_id, user_name, &own_ticket).await?; let devices = device_profiles(pool, user_id).await?; let vector = vector(pool, user_id).await?; - let ops = ops_for_peer(pool, user_id, &invite.device_id).await?; - let snapshot = snapshot(pool, user_id).await?; - let playback = local_playback_snapshot(pool, Arc::clone(&hub), user_id, &identity).await; + // The request is sent before the inviter reports a version: gate it by + // the invite (version 1 for invites from older clients). + let inviter_version = invite.inviter_protocol_version(); + let ops = ops_for_peer(pool, user_id, &invite.device_id, inviter_version).await?; + let snapshot = snapshot(pool, user_id).await?.for_peer(inviter_version); + let playback = + local_playback_snapshot(pool, Arc::clone(&hub), user_id, &identity, inviter_version).await; let mut stream = service.open_stream(peer, SYNC_ALPN).await?; record_stream_transport(&transport_stats, "device-sync", "outbound", "open", &stream); write_msg( @@ -1220,7 +948,14 @@ async fn try_connect_invite( set_group_id(pool, user_id, &group_id).await?; if let Some(profile) = profile { enforce_single_user_binding(pool, user_id, &profile.device_id).await?; - apply_device_profile(pool, user_id, &profile, true).await?; + apply_device_profile( + pool, + user_id, + &profile, + VersionReport::SelfReported(Some(profile.protocol_version)), + true, + ) + .await?; if let Some(playback) = playback { apply_playback_snapshot( Arc::clone(&hub), @@ -1232,7 +967,7 @@ async fn try_connect_invite( .await?; } } - apply_device_profiles(pool, user_id, &devices).await?; + apply_device_profiles(pool, user_id, &devices, Some(&invite.device_id)).await?; apply_snapshot(pool, user_id, snapshot).await?; apply_ops(pool, Arc::clone(&hub), user_id, ops).await?; record_local_op( @@ -1446,7 +1181,14 @@ async fn handle_pair_request( let own_ticket = service.ticket().await?.to_string(); let own_profile = own_profile(pool, user_id, "", &own_ticket).await?; - apply_device_profile(pool, user_id, &profile, true).await?; + apply_device_profile( + pool, + user_id, + &profile, + VersionReport::SelfReported(Some(profile.protocol_version)), + true, + ) + .await?; if let Some(playback) = playback { apply_playback_snapshot( Arc::clone(&hub), @@ -1459,7 +1201,13 @@ async fn handle_pair_request( } apply_snapshot(pool, user_id, incoming_snapshot).await?; apply_ops(pool, Arc::clone(&hub), user_id, ops).await?; - apply_device_profiles(pool, user_id, &requester_group_devices).await?; + apply_device_profiles( + pool, + user_id, + &requester_group_devices, + Some(&profile.device_id), + ) + .await?; note_peer_vector(pool, user_id, &profile.device_id, &incoming_vector).await?; sqlx::query("UPDATE furumusic__fed_device_invite SET used_at_ms = $2 WHERE invite_id = $1") .bind(&invite_id) @@ -1473,11 +1221,12 @@ async fn handle_pair_request( ) .await?; + let peer_version = stored_protocol_version(pool, user_id, &profile.device_id).await?; let devices = device_profiles(pool, user_id).await?; let vector = vector(pool, user_id).await?; - let ops = ops_for_peer(pool, user_id, &profile.device_id).await?; - let snapshot = snapshot(pool, user_id).await?; - let playback = local_playback_snapshot(pool, hub, user_id, &identity).await; + let ops = ops_for_peer(pool, user_id, &profile.device_id, peer_version).await?; + let snapshot = snapshot(pool, user_id).await?.for_peer(peer_version); + let playback = local_playback_snapshot(pool, hub, user_id, &identity, peer_version).await; write_msg( &mut stream, &WireMessage::PairResponse { @@ -1522,8 +1271,15 @@ async fn handle_hello( return write_sync_reject(stream, "sync group mismatch").await; } profile.endpoint_id = stream.peer_id.to_string(); - apply_device_profile(pool, user_id, &profile, false).await?; - apply_device_profiles(pool, user_id, &devices).await?; + apply_device_profile( + pool, + user_id, + &profile, + VersionReport::SelfReported(Some(profile.protocol_version)), + false, + ) + .await?; + apply_device_profiles(pool, user_id, &devices, Some(&profile.device_id)).await?; if let Some(playback) = playback { apply_playback_snapshot( Arc::clone(&hub), @@ -1555,10 +1311,11 @@ async fn handle_hello( let own_profile = own_profile(pool, user_id, "", &own_ticket).await?; let mut devices = device_profiles(pool, user_id).await?; devices.push(own_profile); + let peer_version = stored_protocol_version(pool, user_id, &profile.device_id).await?; let vector = vector(pool, user_id).await?; - let ops = ops_for_peer(pool, user_id, &profile.device_id).await?; - let snapshot = snapshot(pool, user_id).await?; - let playback = local_playback_snapshot(pool, hub, user_id, &identity).await; + let ops = ops_for_peer(pool, user_id, &profile.device_id, peer_version).await?; + let snapshot = snapshot(pool, user_id).await?.for_peer(peer_version); + let playback = local_playback_snapshot(pool, hub, user_id, &identity, peer_version).await; write_msg( &mut stream, &WireMessage::SyncResponse { @@ -1589,11 +1346,13 @@ async fn sync_device( let own_ticket = service.ticket().await?.to_string(); let identity = ensure_identity(pool, user_id, "").await?; let profile = own_profile(pool, user_id, "", &own_ticket).await?; + let peer_version = stored_protocol_version(pool, user_id, &device.device_id).await?; let devices = device_profiles(pool, user_id).await?; let vector = vector(pool, user_id).await?; - let ops = ops_for_peer(pool, user_id, &device.device_id).await?; - let snapshot = snapshot(pool, user_id).await?; - let playback = local_playback_snapshot(pool, Arc::clone(&hub), user_id, &identity).await; + let ops = ops_for_peer(pool, user_id, &device.device_id, peer_version).await?; + let snapshot = snapshot(pool, user_id).await?.for_peer(peer_version); + let playback = + local_playback_snapshot(pool, Arc::clone(&hub), user_id, &identity, peer_version).await; let mut stream = service.open_stream(peer, SYNC_ALPN).await?; record_stream_transport(&transport_stats, "device-sync", "outbound", "open", &stream); write_msg( @@ -1624,7 +1383,9 @@ async fn sync_device( playback, .. } => { - apply_device_profiles(pool, user_id, &devices).await?; + // A SyncResponse has no profile: the responder's own entry in + // `devices` is its version report. + apply_device_profiles(pool, user_id, &devices, Some(&device.device_id)).await?; if let Some(playback) = playback { apply_playback_snapshot( Arc::clone(&hub), @@ -1930,6 +1691,14 @@ async fn own_profile( ) -> Result { let identity = ensure_identity(pool, user_id, user_name).await?; let endpoint_id = ticket_endpoint_id(endpoint_ticket).unwrap_or_default(); + let previous_version: Option = sqlx::query_scalar( + "SELECT protocol_version FROM furumusic__fed_device + WHERE user_id = $1 AND device_id = $2", + ) + .bind(user_id) + .bind(&identity.device_id) + .fetch_optional(pool) + .await?; let now = now_ms(); sqlx::query( "INSERT INTO furumusic__fed_device @@ -1954,6 +1723,23 @@ async fn own_profile( .bind(now) .execute(pool) .await?; + if previous_version.is_some_and(|version| version < i32::from(PROTOCOL_VERSION)) { + // First start of a new protocol version: announce it in the log too, + // so devices that only see this device's operations through relays + // learn the version (`profile_protocol_version`). + record_local_op( + pool, + user_id, + SyncOpPayload::DeviceProfileSet { + name: identity.name.clone(), + client_version: CLIENT_VERSION.to_string(), + endpoint_ticket: endpoint_ticket.to_string(), + endpoint_id: endpoint_id.clone(), + protocol_version: Some(PROTOCOL_VERSION), + }, + ) + .await?; + } Ok(DeviceProfileWire { device_id: identity.device_id, name: identity.name, @@ -2016,24 +1802,7 @@ async fn record_local_op( hlc_ms, payload, }; - sqlx::query( - "INSERT INTO furumusic__fed_sync_ops - (user_id, op_id, origin_device_id, seq, kind, payload_json, hlc_ms, - received_at_ms, tombstone) - VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) - ON CONFLICT (user_id, op_id) DO NOTHING", - ) - .bind(user_id) - .bind(&op.op_id) - .bind(&op.origin_device_id) - .bind(op.seq) - .bind(payload_kind(&op.payload)) - .bind(serde_json::to_value(&op.payload)?) - .bind(op.hlc_ms) - .bind(now_ms()) - .bind(op.payload.is_tombstone()) - .execute(pool) - .await?; + insert_op(pool, user_id, &op).await?; sqlx::query( "INSERT INTO furumusic__fed_sync_vector (user_id, device_id, max_seq) VALUES ($1, $2, $3) @@ -2059,26 +1828,11 @@ async fn apply_ops( if !should_accept_op(pool, user_id, &op).await? { continue; } - let inserted = sqlx::query( - "INSERT INTO furumusic__fed_sync_ops - (user_id, op_id, origin_device_id, seq, kind, payload_json, hlc_ms, - received_at_ms, tombstone) - VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) - ON CONFLICT (user_id, op_id) DO NOTHING", - ) - .bind(user_id) - .bind(&op.op_id) - .bind(&op.origin_device_id) - .bind(op.seq) - .bind(payload_kind(&op.payload)) - .bind(serde_json::to_value(&op.payload)?) - .bind(op.hlc_ms) - .bind(now_ms()) - .bind(op.payload.is_tombstone()) - .execute(pool) - .await? - .rows_affected(); - if inserted > 0 { + // Podcast operations that break the contract are skipped but still + // acknowledged (the vector below advances), so the log keeps moving. + if let Err(error) = op.validate_podcast() { + tracing::debug!(op_id = %op.op_id, "skipped invalid podcast operation: {error}"); + } else if insert_op(pool, user_id, &op).await? { let _ = apply_op(pool, Arc::clone(&hub), user_id, &op).await?; } sqlx::query( @@ -2096,6 +1850,30 @@ async fn apply_ops( Ok(()) } +/// Appends an operation to the log; `false` when it was already stored. +async fn insert_op(pool: &sqlx::PgPool, user_id: i64, op: &SyncOpWire) -> Result { + let inserted = sqlx::query( + "INSERT INTO furumusic__fed_sync_ops + (user_id, op_id, origin_device_id, seq, kind, payload_json, hlc_ms, + received_at_ms, tombstone) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) + ON CONFLICT (user_id, op_id) DO NOTHING", + ) + .bind(user_id) + .bind(&op.op_id) + .bind(&op.origin_device_id) + .bind(op.seq) + .bind(payload_kind(&op.payload)) + .bind(serde_json::to_value(&op.payload)?) + .bind(op.hlc_ms) + .bind(now_ms()) + .bind(op.payload.is_tombstone()) + .execute(pool) + .await? + .rows_affected(); + Ok(inserted > 0) +} + async fn should_accept_op(pool: &sqlx::PgPool, user_id: i64, op: &SyncOpWire) -> Result { let identity = ensure_identity(pool, user_id, "").await?; if op.origin_device_id == identity.device_id { @@ -2201,19 +1979,29 @@ async fn apply_op( client_version, endpoint_ticket, endpoint_id, + protocol_version, } => { + // The origin's own report: never substitute this server's version. let profile = DeviceProfileWire { device_id: op.origin_device_id.clone(), name: name.clone(), client_version: client_version.clone(), - protocol_version: PROTOCOL_VERSION, + protocol_version: protocol_version + .unwrap_or(music_dht::device_sync::UNREPORTED_PROTOCOL_VERSION), endpoint_id: endpoint_id.clone(), endpoint_ticket: endpoint_ticket.clone(), revoked: false, revoke_cutoff_seq: None, updated_at_ms: op.hlc_ms, }; - apply_device_profile(pool, user_id, &profile, false).await?; + apply_device_profile( + pool, + user_id, + &profile, + VersionReport::SelfReported(*protocol_version), + false, + ) + .await?; Ok(false) } SyncOpPayload::DeviceTrusted { target_device_id } => { @@ -2240,6 +2028,18 @@ async fn apply_op( SyncOpPayload::ListenRecorded { event } => { apply_listen_event(pool, user_id, &op.origin_device_id, event).await } + SyncOpPayload::PodcastSubscriptionSet { .. } + | SyncOpPayload::PodcastShareSet { .. } + | SyncOpPayload::PodcastFeedAliasesAdded { .. } + | SyncOpPayload::PodcastProgressSet { .. } + | SyncOpPayload::PodcastListenRecorded { .. } => { + // The web player has no podcast features yet: keep the registers + // for this device's snapshots; the operation itself is relayed + // from the log. + let records: Vec<_> = RelayRecord::from_op(op).into_iter().collect(); + podcast_relay::merge_records(pool, user_id, &records).await?; + Ok(false) + } } } @@ -2605,6 +2405,13 @@ async fn apply_playlist_item_state( } async fn apply_snapshot(pool: &sqlx::PgPool, user_id: i64, snapshot: SyncSnapshot) -> Result<()> { + let podcast = SyncSnapshot { + podcast_subscriptions: snapshot.podcast_subscriptions.clone(), + podcast_shares: snapshot.podcast_shares.clone(), + podcast_progress: snapshot.podcast_progress.clone(), + podcast_listen_sessions: snapshot.podcast_listen_sessions.clone(), + ..SyncSnapshot::default() + }; for like in snapshot.likes { apply_like_state( pool, @@ -2681,24 +2488,79 @@ async fn apply_snapshot(pool: &sqlx::PgPool, user_id: i64, snapshot: SyncSnapsho ) .await?; } + podcast_relay::merge_records(pool, user_id, &RelayRecord::from_snapshot(&podcast)).await?; Ok(()) } +/// How the protocol version in a device profile became known. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum VersionReport { + /// The device reported its own version (`None`: an older client left it + /// out). Replaces the stored version. + SelfReported(Option), + /// Another device relayed the profile. Only raises the stored version: + /// v1–v3 relays substitute their own constant. + Relayed(u16), +} + +impl VersionReport { + fn resolve(self, stored: Option) -> u16 { + match self { + VersionReport::SelfReported(reported) => profile_protocol_version(reported, stored), + VersionReport::Relayed(relayed) => relayed_protocol_version(relayed, stored), + } + } + + /// Report carried by an entry of a `devices` list sent by `sender`. + fn for_listed(profile: &DeviceProfileWire, sender: Option<&str>) -> Self { + if sender == Some(profile.device_id.as_str()) { + VersionReport::SelfReported(Some(profile.protocol_version)) + } else { + VersionReport::Relayed(profile.protocol_version) + } + } +} + +/// Stores the profiles of a `devices` list. The entry of the authenticated +/// `sender` is its own version report; the others are relayed. async fn apply_device_profiles( pool: &sqlx::PgPool, user_id: i64, devices: &[DeviceProfileWire], + sender: Option<&str>, ) -> Result<()> { for profile in devices { - apply_device_profile(pool, user_id, profile, false).await?; + let report = VersionReport::for_listed(profile, sender); + apply_device_profile(pool, user_id, profile, report, false).await?; } Ok(()) } +/// Version gating input for a peer: the version it reported itself. +async fn stored_protocol_version( + pool: &sqlx::PgPool, + user_id: i64, + device_id: &str, +) -> Result { + let stored: Option = sqlx::query_scalar( + "SELECT protocol_version FROM furumusic__fed_device + WHERE user_id = $1 AND device_id = $2", + ) + .bind(user_id) + .bind(device_id) + .fetch_optional(pool) + .await?; + Ok(profile_protocol_version( + None, + stored.and_then(|value| u16::try_from(value).ok()), + )) +} + async fn apply_device_profile( pool: &sqlx::PgPool, user_id: i64, profile: &DeviceProfileWire, + version: VersionReport, trusted: bool, ) -> Result<()> { let identity = ensure_identity(pool, user_id, "").await?; @@ -2706,6 +2568,15 @@ async fn apply_device_profile( return Ok(()); } enforce_single_user_binding(pool, user_id, &profile.device_id).await?; + let stored: Option = sqlx::query_scalar( + "SELECT protocol_version FROM furumusic__fed_device + WHERE user_id = $1 AND device_id = $2", + ) + .bind(user_id) + .bind(&profile.device_id) + .fetch_optional(pool) + .await?; + let protocol_version = version.resolve(stored.and_then(|value| u16::try_from(value).ok())); let trusted_at_ms = trusted.then_some(now_ms()).or(Some(profile.updated_at_ms)); sqlx::query( "INSERT INTO furumusic__fed_device @@ -2743,7 +2614,7 @@ async fn apply_device_profile( .bind(&profile.device_id) .bind(&profile.name) .bind(&profile.client_version) - .bind(profile.protocol_version as i32) + .bind(i32::from(protocol_version)) .bind(&profile.endpoint_id) .bind(&profile.endpoint_ticket) .bind(trusted_at_ms) @@ -2848,6 +2719,21 @@ async fn apply_playback_command( let origin = &op.origin_device_id; let op_id = &op.op_id; let identity = ensure_identity(pool, user_id, "").await?; + // A peer below v4 does not know podcast items: its state would silently + // drop them from the local queue. + let peer_version = stored_protocol_version(pool, user_id, origin).await?; + let local = hub + .playback_state_json_for_commands(user_id) + .map(|state| browser_state_shadow(&state)) + .unwrap_or_else(|| queue_items::shadow_wire_state(&[], 0)); + if !playback_command_allowed_from_peer(&local, peer_version) { + tracing::info!( + origin = %short_id(origin), + peer_version, + "ignored playback command from a device without podcast support" + ); + return Ok(()); + } let Some(authority) = authority else { return Ok(()); }; @@ -3009,6 +2895,7 @@ pub async fn record_web_playback_command( ensure_web_playback_target(pool, user_id, target_device_id).await?; let next_state = browser_state_for_command(command, payload, current_state)?; let wire = playback_state_from_browser_json(pool, next_state.clone()).await?; + ensure_playback_supported_by(pool, user_id, target_device_id, &wire).await?; record_local_op( pool, user_id, @@ -3037,6 +2924,8 @@ pub async fn record_web_active_transfer( ) -> Result<()> { ensure_web_playback_target(pool, user_id, target_device_id).await?; let wire = playback_state_from_browser_json(pool, state).await?; + // Refuse instead of stripping podcast episodes from the queue. + ensure_playback_supported_by(pool, user_id, target_device_id, &wire).await?; let target_name = web_playback_target_name(pool, user_id, target_device_id).await?; let identity = ensure_identity(pool, user_id, "").await?; with_playback_engine(pool, user_id, &identity, |engine| { @@ -3081,6 +2970,17 @@ pub async fn record_web_active_transfer( Ok(()) } +/// Checks before a handoff that the target can receive the queue. +pub async fn check_web_transfer( + pool: &sqlx::PgPool, + user_id: i64, + target_device_id: &str, + state: serde_json::Value, +) -> Result<()> { + let wire = playback_state_from_browser_json(pool, state).await?; + ensure_playback_supported_by(pool, user_id, target_device_id, &wire).await +} + pub async fn record_web_active_takeover( pool: &sqlx::PgPool, user_id: i64, @@ -3111,6 +3011,28 @@ pub async fn record_web_active_takeover( Ok(()) } +/// Refuses to hand a queue with podcast items to a device below v4. +async fn ensure_playback_supported_by( + pool: &sqlx::PgPool, + user_id: i64, + device_id: &str, + state: &PlaybackStateWire, +) -> Result<()> { + let version = stored_protocol_version(pool, user_id, device_id).await?; + if !playback_allowed_for_peer(state, version) { + let name = web_playback_target_name(pool, user_id, device_id).await?; + anyhow::bail!( + "{name} needs an update to play podcast episodes. Update Furumi on that device, or remove the episodes from the queue." + ); + } + Ok(()) +} + +/// Wire-shaped view of a browser playback state for the shared gating helpers. +fn browser_state_shadow(state: &serde_json::Value) -> PlaybackStateWire { + queue_items::shadow_wire_state(&browser_tracks(state), browser_index(state)) +} + async fn ensure_web_playback_target( pool: &sqlx::PgPool, user_id: i64, @@ -3554,11 +3476,14 @@ async fn web_playback_payload( })) } +/// Playback snapshot for a peer, or `None` when the queue has podcast items +/// and the peer is below v4 (`playback_allowed_for_peer`): never strip them. async fn local_playback_snapshot( pool: &sqlx::PgPool, hub: Arc, user_id: i64, identity: &Identity, + peer_version: u16, ) -> Option { let coordination = coordinate_web_output(pool, Arc::clone(&hub), user_id, identity) .await @@ -3571,6 +3496,9 @@ async fn local_playback_snapshot( .playback_state_json_for_commands(user_id) .unwrap_or_else(|| serde_json::json!({})); let wire = playback_state_from_browser_json(pool, state).await.ok()?; + if !playback_allowed_for_peer(&wire, peer_version) { + return None; + } Some(PlaybackSnapshot { device_id: identity.device_id.clone(), device_name: identity.name.clone(), @@ -3703,19 +3631,27 @@ async fn playback_state_from_browser_json( .and_then(serde_json::Value::as_array) .cloned() .unwrap_or_default(); + let mut queue_pos = state + .get("index") + .and_then(serde_json::Value::as_i64) + .unwrap_or(0) + .max(0) as usize; let mut queue = Vec::new(); - for track in tracks_value { - if let Some(track_id) = track.get("id").and_then(serde_json::Value::as_i64) { - queue.push(playback_track_from_track_json(pool, track_id, &track).await?); + for (index, track) in tracks_value.iter().enumerate() { + // Items that are not library tracks keep their verbatim wire item, + // including the explicit source (podcast episodes, placeholders). + if let Some(wire) = queue_items::wire_track_from_browser_json(track) { + queue.push(wire); + } else if let Some(track_id) = track.get("id").and_then(serde_json::Value::as_i64) { + queue.push(playback_track_from_track_json(pool, track_id, track).await?); + } else if index < queue_pos { + // A malformed entry is skipped; keep the position on its item. + queue_pos -= 1; } } Ok(PlaybackStateWire { queue, - queue_pos: state - .get("index") - .and_then(serde_json::Value::as_i64) - .unwrap_or(0) - .max(0) as usize, + queue_pos, playing: state.get("track").is_some_and(|track| !track.is_null()), paused: state .get("paused") @@ -3746,6 +3682,8 @@ async fn playback_state_from_browser_json( "all" => PlaybackRepeat::All, _ => PlaybackRepeat::Off, }, + // Reserved; the web player has no variable speed. + playback_rate: None, }) } @@ -3754,6 +3692,15 @@ async fn playback_track_from_track_json( track_id: i64, track: &serde_json::Value, ) -> Result { + let content_id = match track + .get("content_id") + .and_then(serde_json::Value::as_str) + .and_then(music_dht::normalize_content_id) + { + Some(content_id) => Some(content_id), + None if track_id > 0 => track_content_id(pool, track_id).await?, + None => None, + }; Ok(PlaybackTrack { id: track_id, title: track @@ -3789,15 +3736,7 @@ async fn playback_track_from_track_json( .and_then(serde_json::Value::as_i64) .map(|value| value as i32), file_path: String::new(), - content_id: track - .get("content_id") - .and_then(serde_json::Value::as_str) - .and_then(music_dht::normalize_content_id) - .or(if track_id > 0 { - track_content_id(pool, track_id).await? - } else { - None - }), + content_id, audio_format: track .get("audio_format") .and_then(serde_json::Value::as_str) @@ -3819,6 +3758,7 @@ async fn playback_track_from_track_json( .and_then(serde_json::Value::as_i64), play_count: 0, fed: None, + source: None, }) } @@ -3836,31 +3776,50 @@ fn names_from_track_json(track: &serde_json::Value, field: &str) -> Vec .unwrap_or_default() } -async fn resolve_playback_tracks( +/// Browser JSON of wire queue items, in order and without dropping any. +/// +/// Music resolved by content id becomes the library track; everything else +/// (unresolved music, podcast episodes, Jam placeholders) becomes an +/// external item that keeps the verbatim wire DTO. +pub(crate) async fn resolve_playback_tracks( pool: &sqlx::PgPool, tracks: &[PlaybackTrack], ) -> Result> { - let mut out = Vec::new(); + let mut out = Vec::with_capacity(tracks.len()); for (index, track) in tracks.iter().enumerate() { - let content_id = track - .content_id - .as_deref() - .or_else(|| track.fed.as_ref().map(|fed| fed.content_id.as_str())) - .and_then(music_dht::normalize_content_id); - let Some(content_id) = content_id else { - out.push(placeholder_playback_track(track, index, None)); - continue; - }; - if let Some(track_json) = web_track_json_by_content_id(pool, &content_id).await? { - out.push(track_json); - } else { - tracing::debug!(content_id, title = %track.title, "fed playback track is not available locally on web"); - out.push(placeholder_playback_track(track, index, Some(&content_id))); - } + out.push(resolve_playback_track(pool, track, index).await?); } Ok(out) } +/// Browser JSON of one wire queue item at queue position `index`. +pub(crate) async fn resolve_playback_track( + pool: &sqlx::PgPool, + track: &PlaybackTrack, + index: usize, +) -> Result { + if track.requires_podcast_support() { + return Ok(queue_items::external_track_json(track, index, None)); + } + let content_id = track + .content_id + .as_deref() + .or_else(|| track.fed.as_ref().map(|fed| fed.content_id.as_str())) + .and_then(music_dht::normalize_content_id); + let Some(content_id) = content_id else { + return Ok(queue_items::external_track_json(track, index, None)); + }; + if let Some(track_json) = web_track_json_by_content_id(pool, &content_id).await? { + return Ok(track_json); + } + tracing::debug!(content_id, title = %track.title, "fed playback track is not available locally on web"); + Ok(queue_items::external_track_json( + track, + index, + Some(&content_id), + )) +} + async fn web_track_json_by_content_id( pool: &sqlx::PgPool, content_id: &str, @@ -3962,83 +3921,6 @@ async fn track_artist_names(pool: &sqlx::PgPool, track_id: i64, role: &str) -> R Ok(rows.into_iter().map(|row| row.get("name")).collect()) } -fn placeholder_playback_track( - track: &PlaybackTrack, - index: usize, - content_id: Option<&str>, -) -> serde_json::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": "Not available on this web player yet", - }) -} - -fn artist_names_to_json(names: &[String]) -> Vec { - 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(content_id: Option<&str>, index: usize) -> i64 { - let mut bytes = [0u8; 8]; - let hash = blake3::hash(content_id.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) -} - async fn track_id_by_content_id(pool: &sqlx::PgPool, content_id: &str) -> Result> { let Some(content_id) = music_dht::normalize_content_id(content_id) else { return Ok(None); @@ -4471,11 +4353,23 @@ async fn note_peer_vector( Ok(()) } +/// Operations the peer has not acknowledged and can parse. +/// +/// Kinds the peer's version does not know are excluded in SQL; skipped +/// operations are never re-sent after an upgrade (vectors only grow), the +/// snapshot is the recovery path for them. async fn ops_for_peer( pool: &sqlx::PgPool, user_id: i64, peer_device_id: &str, + peer_version: u16, ) -> Result> { + // This server only speaks `furumi/sync/2`, so every peer it exchanges + // operations with implements v2 (listen history) even when it never + // reported a version (an invite without `p`, a device known only from + // `device_trusted`). Without this floor listen events would be skipped + // for good: they are not part of snapshots. + let peer_version = peer_version.max(SYNC_V2_PROTOCOL_VERSION); let rows = sqlx::query( "SELECT o.op_id, o.origin_device_id, o.seq, o.hlc_ms, o.payload_json FROM furumusic__fed_sync_ops o @@ -4492,6 +4386,7 @@ async fn ops_for_peer( AND o.payload_json->>'target_device_id' = $2 ) ) + AND NOT (o.kind = ANY($5)) ORDER BY o.hlc_ms, o.op_id LIMIT $4", ) @@ -4499,20 +4394,25 @@ async fn ops_for_peer( .bind(peer_device_id) .bind(now_ms().saturating_sub(PLAYBACK_COMMAND_TTL_MS)) .bind(MAX_OPS_PER_BATCH) + .bind(op_kinds_hidden_from(peer_version)) .fetch_all(pool) .await?; - rows.into_iter() - .map(|row| { - let payload_json: serde_json::Value = row.get("payload_json"); - Ok(SyncOpWire { - op_id: row.get("op_id"), - origin_device_id: row.get("origin_device_id"), - seq: row.get("seq"), - hlc_ms: row.get("hlc_ms"), - payload: serde_json::from_value(payload_json)?, - }) - }) - .collect() + let mut ops = Vec::with_capacity(rows.len()); + for row in rows { + let payload_json: serde_json::Value = row.get("payload_json"); + let op = SyncOpWire { + op_id: row.get("op_id"), + origin_device_id: row.get("origin_device_id"), + seq: row.get("seq"), + hlc_ms: row.get("hlc_ms"), + payload: serde_json::from_value(payload_json)?, + }; + // Playback commands carrying podcast items need v4 as well. + if op_allowed_for_peer(&op.payload, peer_version) { + ops.push(op); + } + } + Ok(ops) } async fn snapshot(pool: &sqlx::PgPool, user_id: i64) -> Result { @@ -4601,13 +4501,16 @@ async fn snapshot(pool: &sqlx::PgPool, user_id: i64) -> Result { op_id: row.get("op_id"), }) .collect(); - Ok(SyncSnapshot { + let mut snapshot = SyncSnapshot { likes, unlikes, playlists, deleted_playlists, removed_playlist_items, - }) + ..SyncSnapshot::default() + }; + podcast_relay::fill_snapshot(pool, user_id, &mut snapshot).await?; + Ok(snapshot) } async fn snapshot_playlist_items( @@ -4839,6 +4742,7 @@ async fn write_sync_reject(mut stream: ByteStream, message: &str) -> Result<()> finish_response(&mut stream).await } +/// Operation `kind` tag as stored in `furumusic__fed_sync_ops.kind`. fn payload_kind(payload: &SyncOpPayload) -> &'static str { match payload { SyncOpPayload::TrackLikeSet { .. } => "track_like_set", @@ -4852,70 +4756,83 @@ fn payload_kind(payload: &SyncOpPayload) -> &'static str { SyncOpPayload::DeviceRevoked { .. } => "device_revoked", SyncOpPayload::PlaybackCommand { .. } => "playback_command", SyncOpPayload::ListenRecorded { .. } => "listen_recorded", + SyncOpPayload::PodcastSubscriptionSet { .. } => "podcast_subscription_set", + SyncOpPayload::PodcastShareSet { .. } => "podcast_share_set", + SyncOpPayload::PodcastFeedAliasesAdded { .. } => "podcast_feed_aliases_added", + SyncOpPayload::PodcastProgressSet { .. } => "podcast_progress_set", + SyncOpPayload::PodcastListenRecorded { .. } => "podcast_listen_recorded", } } +/// Stored operation kinds a peer of `peer_version` cannot parse. +/// +/// Filtered in SQL so a batch of hidden operations cannot stall the +/// per-peer cursor; `op_allowed_for_peer` stays the final check. +fn op_kinds_hidden_from(peer_version: u16) -> Vec<&'static str> { + let mut kinds = Vec::new(); + if !supports_listen_history(peer_version) { + kinds.push("listen_recorded"); + } + if !supports_podcasts(peer_version) { + kinds.extend([ + "podcast_subscription_set", + "podcast_share_set", + "podcast_feed_aliases_added", + "podcast_progress_set", + "podcast_listen_recorded", + ]); + } + kinds +} + +/// Bounds the podcast snapshot sections so the whole line stays under the +/// protocol limit (`podcast_snapshot_budget`). +fn fit_podcast_snapshot(message: &mut WireMessage) { + let snapshot = match message { + WireMessage::PairRequest { snapshot, .. } + | WireMessage::PairResponse { snapshot, .. } + | WireMessage::Hello { snapshot, .. } + | WireMessage::SyncResponse { snapshot, .. } => snapshot, + }; + if !snapshot.has_podcast_state() { + return; + } + let podcast = snapshot.clone(); + snapshot.strip_podcast_state(); + let other_bytes = serde_json::to_vec(message).map_or(usize::MAX, |bytes| bytes.len()); + let snapshot = match message { + WireMessage::PairRequest { snapshot, .. } + | WireMessage::PairResponse { snapshot, .. } + | WireMessage::Hello { snapshot, .. } + | WireMessage::SyncResponse { snapshot, .. } => snapshot, + }; + *snapshot = podcast; + snapshot.bound_podcast_state_to(podcast_snapshot_budget(other_bytes)); +} + async fn write_msg(stream: &mut ByteStream, message: &WireMessage) -> Result<()> { - let mut payload = serde_json::to_vec(message)?; - payload.push(b'\n'); - stream.send.write_all(&payload).await?; + let mut message = message.clone(); + fit_podcast_snapshot(&mut message); + music_dht::device_sync::write_msg(stream, &message).await?; Ok(()) } async fn finish_send(stream: &mut ByteStream) -> Result<()> { - stream.send.finish()?; + music_dht::device_sync::finish_send(stream).await?; Ok(()) } async fn finish_response(stream: &mut ByteStream) -> Result<()> { - stream.send.finish()?; - let _ = tokio::time::timeout(RESPONSE_DRAIN_TIMEOUT, stream.send.stopped()).await; + music_dht::device_sync::finish_response(stream, RESPONSE_DRAIN_TIMEOUT).await?; Ok(()) } async fn read_msg(stream: &mut ByteStream) -> Result { - let line = read_line(&mut stream.recv).await?; - Ok(serde_json::from_slice(&line)?) -} - -async fn read_line(reader: &mut R) -> Result> { - let mut out = Vec::new(); - loop { - let mut byte = [0u8; 1]; - let read = reader.read(&mut byte).await?; - if read == 0 { - break; - } - if byte[0] == b'\n' { - break; - } - out.push(byte[0]); - if out.len() > MAX_LINE { - anyhow::bail!("protocol line is too large"); - } - } - Ok(out) -} - -fn parse_invite(value: &str) -> Result { - let Some(token) = value.trim().strip_prefix("frid://i/") else { - anyhow::bail!("usage: frid://i/"); - }; - let bytes = base64url_decode(token)?; - let invite: InviteWire = serde_json::from_slice(&bytes)?; - anyhow::ensure!(invite.v == 1, "unsupported invite version"); - Ok(invite) + Ok(music_dht::device_sync::read_msg(stream).await?) } pub fn invite_network_id(value: &str) -> Result { - let invite = parse_invite(value)?; - let ticket: PeerTicket = invite.ticket.parse().context("malformed invite ticket")?; - Ok(ticket.network_id) -} - -fn encode_invite(invite: &InviteWire) -> Result { - let bytes = serde_json::to_vec(invite)?; - Ok(format!("frid://i/{}", base64url_encode(&bytes))) + Ok(music_dht::device_sync::invite_network_id(value)?) } fn pair_request_id(invite_id: &str, device_id: &str) -> String { @@ -4923,24 +4840,6 @@ fn pair_request_id(invite_id: &str, device_id: &str) -> String { format!("pair_{}", &digest.to_hex()[..16]) } -fn hash_secret(secret: &str) -> String { - blake3::hash(secret.as_bytes()).to_hex().to_string() -} - -fn random_hex(bytes: usize) -> String { - let key = SecretKey::generate(); - let mut seed = key.to_bytes().to_vec(); - while seed.len() < bytes { - seed.extend_from_slice(blake3::hash(&seed).as_bytes()); - } - hex_encode(&seed[..bytes]) -} - -fn ticket_endpoint_id(ticket: &str) -> Option { - let ticket = PeerTicket::from_str(ticket).ok()?; - Some(ticket.endpoint_id().to_string()) -} - fn repeat_label(repeat: PlaybackRepeat) -> &'static str { match repeat { PlaybackRepeat::Off => "off", @@ -4987,62 +4886,11 @@ fn short_id(value: &str) -> String { value.chars().take(10).collect() } -fn hex_encode(bytes: &[u8]) -> String { - bytes.iter().map(|byte| format!("{byte:02x}")).collect() -} - -fn base64url_encode(bytes: &[u8]) -> String { - const TABLE: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"; - let mut out = String::new(); - let mut i = 0; - while i < bytes.len() { - let b0 = bytes[i]; - let b1 = bytes.get(i + 1).copied().unwrap_or(0); - let b2 = bytes.get(i + 2).copied().unwrap_or(0); - out.push(TABLE[(b0 >> 2) as usize] as char); - out.push(TABLE[(((b0 & 0b0000_0011) << 4) | (b1 >> 4)) as usize] as char); - if i + 1 < bytes.len() { - out.push(TABLE[(((b1 & 0b0000_1111) << 2) | (b2 >> 6)) as usize] as char); - } - if i + 2 < bytes.len() { - out.push(TABLE[(b2 & 0b0011_1111) as usize] as char); - } - i += 3; - } - out -} - -fn base64url_decode(value: &str) -> Result> { - fn val(byte: u8) -> Option { - match byte { - b'A'..=b'Z' => Some(byte - b'A'), - b'a'..=b'z' => Some(byte - b'a' + 26), - b'0'..=b'9' => Some(byte - b'0' + 52), - b'-' => Some(62), - b'_' => Some(63), - _ => None, - } - } - let bytes = value.as_bytes(); - let mut out = Vec::with_capacity(bytes.len() * 3 / 4); - let mut i = 0; - while i < bytes.len() { - let a = val(bytes[i]).context("invalid base64url invite")?; - let b = val(*bytes.get(i + 1).context("truncated base64url invite")?) - .context("invalid base64url invite")?; - let c = bytes.get(i + 2).and_then(|byte| val(*byte)); - let d = bytes.get(i + 3).and_then(|byte| val(*byte)); - out.push((a << 2) | (b >> 4)); - if let Some(c) = c { - out.push((b << 4) | (c >> 2)); - if let Some(d) = d { - out.push((c << 6) | d); - } - } - i += 4; - } - Ok(out) -} - +#[cfg(test)] +mod gating_tests; #[cfg(test)] mod interop_tests; +#[cfg(test)] +mod postgres_tests; +#[cfg(test)] +mod wire_compat_tests; diff --git a/src/federation/devices/fixtures/v3_hello.golden.json b/src/federation/devices/fixtures/v3_hello.golden.json new file mode 100644 index 0000000..ad7622e --- /dev/null +++ b/src/federation/devices/fixtures/v3_hello.golden.json @@ -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","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"}},"authority":null}},{"op_id":"tui_a:12","origin_device_id":"tui_a","seq":12,"hlc_ms":1700000000012,"payload":{"kind":"listen_recorded","event":{"listen_id":"l1","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","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":"b3:1111111111111111111111111111111111111111111111111111111111111111","hlc_ms":1,"op_id":"tui_a:1","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}}],"unlikes":[{"content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","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":"b3:1111111111111111111111111111111111111111111111111111111111111111","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":"b3:1111111111111111111111111111111111111111111111111111111111111111","hlc_ms":6,"op_id":"tui_a:6"}]},"playback":{"device_id":"tui_a","device_name":"TUI","active":true,"updated_at_ms":9,"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"},"coordination":{"version":1,"claim":{"counter":3,"issuer":"tui_a","owner":"tui_a"},"heartbeat":4,"available":true,"playing":true}}} diff --git a/src/federation/devices/gating_tests.rs b/src/federation/devices/gating_tests.rs new file mode 100644 index 0000000..bc24b3a --- /dev/null +++ b/src/federation/devices/gating_tests.rs @@ -0,0 +1,416 @@ +//! 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) -> 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 { + 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; + + // 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!(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, browser) + .await + .unwrap(); + assert_eq!(outgoing.queue[..4], queue[..]); + assert_eq!(outgoing.queue_pos, 3); + assert!(outgoing.paused); + 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, browser) + .await + .unwrap(); + assert_eq!(wire.queue.len(), 2); + assert_eq!(wire.queue[wire.queue_pos].id, 6); +} diff --git a/src/federation/devices/interop_tests.rs b/src/federation/devices/interop_tests.rs index 7c90357..3979462 100644 --- a/src/federation/devices/interop_tests.rs +++ b/src/federation/devices/interop_tests.rs @@ -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 diff --git a/src/federation/devices/postgres_tests.rs b/src/federation/devices/postgres_tests.rs new file mode 100644 index 0000000..5bdfdc6 --- /dev/null +++ b/src/federation/devices/postgres_tests.rs @@ -0,0 +1,328 @@ +//! 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| { + ops.iter() + .map(|op| payload_kind(&op.payload)) + .collect::>() + }; + 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 = 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; +} + +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 +} diff --git a/src/federation/devices/wire_compat_tests.rs b/src/federation/devices/wire_compat_tests.rs new file mode 100644 index 0000000..176967a --- /dev/null +++ b/src/federation/devices/wire_compat_tests.rs @@ -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)] +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, + #[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, + #[serde(default)] + pub featured_artist_names: Vec, + pub year: Option, + pub duration_seconds: Option, + pub content_id: String, + pub release_title: Option, + pub track_number: Option, + pub disc_number: Option, + } + + #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] + pub struct PlaybackTrack { + pub id: i64, + pub title: String, + pub track_number: Option, + pub disc_number: Option, + pub duration_seconds: f64, + #[serde(default)] + pub artist_names: Vec, + #[serde(default)] + pub featured_artist_names: Vec, + pub release_id: i64, + pub release_title: String, + pub release_year: Option, + #[serde(default)] + pub file_path: String, + pub content_id: Option, + pub audio_format: Option, + pub audio_bitrate: Option, + pub audio_sample_rate: Option, + pub audio_bit_depth: Option, + pub file_size_bytes: Option, + #[serde(default)] + pub play_count: i64, + #[serde(default)] + pub fed: Option, + } + + #[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, + #[serde(default)] + pub queue_pos: usize, + pub playing: bool, + pub paused: bool, + #[serde(default)] + pub idle_since_ms: Option, + pub position_secs: f64, + #[serde(default)] + pub volume: u8, + pub shuffle: bool, + pub repeat: PlaybackRepeat, + } + + pub type PlaybackSnapshot = music_dht::playback::Snapshot; + pub type PlaybackCommand = music_dht::playback::Command; + + #[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, + }, + 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, + }, + 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, + }, + ListenRecorded { + event: ListenEvent, + }, + } + + #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)] + pub struct SyncSnapshot { + #[serde(default)] + pub likes: Vec, + #[serde(default)] + pub unlikes: Vec, + #[serde(default)] + pub playlists: Vec, + #[serde(default)] + pub deleted_playlists: Vec, + #[serde(default)] + pub removed_playlist_items: Vec, + } + + #[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, + } + + #[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, + } + + #[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, + } + + #[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, + #[serde(default)] + group_active_devices: usize, + #[serde(default)] + devices: Vec, + vector: BTreeMap, + ops: Vec, + snapshot: SyncSnapshot, + #[serde(default)] + playback: Option, + }, + PairResponse { + accepted: bool, + #[serde(default)] + pending: bool, + #[serde(default)] + error: Option, + #[serde(default)] + group_id: Option, + #[serde(default)] + profile: Option, + #[serde(default)] + devices: Vec, + #[serde(default)] + vector: BTreeMap, + #[serde(default)] + ops: Vec, + #[serde(default)] + snapshot: SyncSnapshot, + #[serde(default)] + playback: Option, + }, + Hello { + group_id: String, + profile: DeviceProfileWire, + devices: Vec, + vector: BTreeMap, + ops: Vec, + snapshot: SyncSnapshot, + #[serde(default)] + playback: Option, + }, + SyncResponse { + accepted: bool, + #[serde(default)] + error: Option, + #[serde(default)] + devices: Vec, + #[serde(default)] + vector: BTreeMap, + #[serde(default)] + ops: Vec, + #[serde(default)] + snapshot: SyncSnapshot, + #[serde(default)] + playback: Option, + }, + } +} + +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 { + 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::(&new_json).unwrap(), + old + ); + assert_eq!(serde_json::from_str::(&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::(&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::(hello.clone()).is_err()); + assert!(serde_json::from_value::(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 { .. } + )); +} diff --git a/src/federation/mod.rs b/src/federation/mod.rs index 435b019..3302a13 100644 --- a/src/federation/mod.rs +++ b/src/federation/mod.rs @@ -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, diff --git a/src/federation/podcast_relay.rs b/src/federation/podcast_relay.rs new file mode 100644 index 0000000..5ecc329 --- /dev/null +++ b/src/federation/podcast_relay.rs @@ -0,0 +1,557 @@ +//! 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), + /// 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 { + 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 { + 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 { + 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, + incoming: &RelayRecord, +) -> Vec<(DocKey, Option)> { + let own = (incoming.section(), incoming.key().to_string()); + let current = docs.get(&own); + let changed = |merged: Option| { + 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::>); + let merged = match current.and_then(parse::) { + Some(current) => merge_subscription(¤t, 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::(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::>).unwrap_or_default(); + changed(to_value(&merge_feed_aliases(podcast_id, ¤t, aliases))) + .into_iter() + .collect() + } + RelayRecord::Share(record) => changed(match current.and_then(parse::) { + Some(current) => merge_share(¤t, record) + .ok() + .as_ref() + .and_then(to_value), + None => to_value(record), + }) + .into_iter() + .collect(), + RelayRecord::Progress(record) => changed(match current.and_then(parse::) { + Some(current) => merge_progress(¤t, record) + .ok() + .as_ref() + .and_then(to_value), + None => to_value(record), + }) + .into_iter() + .collect(), + RelayRecord::Session(session) => changed(match current.and_then(parse::) { + Some(current) => merge_listen_session(¤t, session) + .ok() + .as_ref() + .and_then(to_value), + None => to_value(session), + }) + .into_iter() + .collect(), + } +} + +fn parse(value: &Value) -> Option { + serde_json::from_value(value.clone()).ok() +} + +fn to_value(value: &T) -> Option { + 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> { + 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(()) +} + +/// 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, §ion, &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, 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) -> 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 + ); + } +} diff --git a/src/i18n/phrases.rs b/src/i18n/phrases.rs index 777e2d1..ca71a59 100644 --- a/src/i18n/phrases.rs +++ b/src/i18n/phrases.rs @@ -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" , "Громкость"; diff --git a/src/library_cleanup.rs b/src/library_cleanup.rs index 8f77a26..4c4df6d 100644 --- a/src/library_cleanup.rs +++ b/src/library_cleanup.rs @@ -20,6 +20,7 @@ struct PlaybackStateRow { current_track_id: Option, position_ms: i32, queue_json: String, + queue_items_json: Option, queue_position: i32, } @@ -738,7 +739,7 @@ async fn cleanup_playback_states( ) -> anyhow::Result<()> { let deleted: HashSet = track_ids.iter().copied().collect(); let states: Vec = 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,7 +747,14 @@ async fn cleanup_playback_states( for state in states { let mut queue: Vec = 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(), + &original_queue, + ); queue.retain(|track_id| !deleted.contains(track_id)); + if let Some(typed) = &mut typed { + typed.retain_library(|track_id| !deleted.contains(&track_id), queue.clone()); + } let current_track_id = state.current_track_id.filter(|id| !deleted.contains(id)); if queue == original_queue && current_track_id == state.current_track_id { continue; @@ -769,10 +777,12 @@ async fn cleanup_playback_states( 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 +790,7 @@ async fn cleanup_playback_states( .bind(position_ms) .bind(queue_json) .bind(queue_position) + .bind(queue_items_json) .execute(&mut **transaction) .await?; } diff --git a/src/music/mod.rs b/src/music/mod.rs index 2ec4b03..c625934 100644 --- a/src/music/mod.rs +++ b/src/music/mod.rs @@ -2838,6 +2838,99 @@ 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(()) + } + + #[cot::db::migrations::migration_op] + async fn drop_fed_podcast_relay(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> { + 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 +2974,7 @@ pub mod db_migrations { &M0050CreateMetadataFixHistory, &M0051AddListenStatisticsIndexes, &M0052AddImportPlaylistDestinations, + &M0054AddTypedPlaybackQueue, + &M0055CreateFedPodcastRelay, ]; } diff --git a/src/player/dto.rs b/src/player/dto.rs index 3c68d40..6d2c47c 100644 --- a/src/player/dto.rs +++ b/src/player/dto.rs @@ -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": }` 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, + /// Index of the current item in `queue_items`. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub(super) queue_items_position: Option, } #[derive(Debug, Deserialize, JsonSchema)] diff --git a/src/player/mod.rs b/src/player/mod.rs index ac6e0bd..f2372dc 100644 --- a/src/player/mod.rs +++ b/src/player/mod.rs @@ -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,14 @@ 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)?; + } (jam.host_user_id, target_id) } else { let target_id = match target_device_id { @@ -1042,11 +1051,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( @@ -1646,6 +1661,86 @@ 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 loaded = queue_items::StoredQueue::from_columns(Some(&column), &[3, 4]).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 page_template_tests { use super::*; @@ -5755,6 +5850,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, ¤t_device_id, &target_device_id) else { return Ok(json_error( @@ -5992,6 +6097,97 @@ 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 { + playback.tracks = queue_items::redact_tracks_for_jam(&playback.tracks); + if playback + .track + .as_ref() + .is_some_and(queue_items::browser_track_requires_podcast_support) + { + let index = usize::try_from(playback.index).unwrap_or(0); + 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. +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 = 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)); + } + } + _ => {} + } + Ok(()) +} + 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 +6516,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 +6527,19 @@ async fn get_state_handler( let dto = match state { Some(s) => { let queue: Vec = serde_json::from_str(&s.queue_json).unwrap_or_default(); + // Prefer the typed queue while it matches `queue_json`. + let typed = queue_items::StoredQueue::from_columns(s.queue_items_json.as_ref(), &queue); + 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 +6548,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 +6560,47 @@ 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 { + 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 { + let items: Vec = + serde_json::from_value(dto.queue_items.clone()?).ok()?; + queue_items::StoredQueue::new( + items, + dto.queue_items_position.unwrap_or(0), + dto.queue.clone(), + ) +} + // --------------------------------------------------------------------------- // PUT /api/player/state // --------------------------------------------------------------------------- @@ -6372,15 +6618,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 +6643,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()))?; diff --git a/src/player/queue_items.rs b/src/player/queue_items.rs new file mode 100644 index 0000000..ab3e1d5 --- /dev/null +++ b/src/player/queue_items.rs @@ -0,0 +1,587 @@ +//! 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"; + +/// 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 { + 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 { + if let Some(wire) = track.get(WIRE_TRACK_KEY).filter(|wire| wire.is_object()) + && let Ok(wire) = serde_json::from_value::(wire.clone()) + { + return Some(wire); + } + match serde_json::from_value::(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 { + 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> { + 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` records the ids written alongside this +/// value: when `queue_json` no longer matches it (an older release or a +/// legacy-only writer changed the queue since), readers ignore the typed +/// value and fall back to `queue_json`. +#[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, + /// `queue_json` ids written together with this value. + #[serde(default)] + pub(crate) legacy_queue: Vec, +} + +/// 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, + }, +} + +impl StoredQueue { + /// Builds the persisted value; `None` when the queue exceeds the bound. + pub(crate) fn new( + items: Vec, + position: usize, + legacy_queue: Vec, + ) -> Option { + (items.len() <= MAX_STORED_QUEUE_ITEMS).then(|| Self { + version: STORED_QUEUE_VERSION, + position: position.min(items.len().saturating_sub(1)), + items, + legacy_queue, + }) + } + + /// Reads the typed column, preferring it over `queue_json` only when it + /// has a known version and still matches the legacy ids. + pub(crate) fn from_columns(typed: Option<&Value>, legacy_queue: &[i64]) -> Option { + let stored = serde_json::from_value::(typed?.clone()).ok()?; + (stored.version == STORED_QUEUE_VERSION + && stored.legacy_queue == legacy_queue + && stored.items.len() <= MAX_STORED_QUEUE_ITEMS) + .then_some(stored) + } + + /// Removes library tracks rejected by `keep` and records the new legacy + /// ids. 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_queue: Vec) { + let mut position = self.position; + let mut index = 0; + let original_position = self.position; + self.items.retain(|item| { + let retained = match item { + StoredQueueItem::Library { track_id } => keep(*track_id), + StoredQueueItem::External { .. } => true, + }; + if !retained && index < original_position { + position = position.saturating_sub(1); + } + index += 1; + retained + }); + self.position = position.min(self.items.len().saturating_sub(1)); + self.legacy_queue = legacy_queue; + } +} + +/// 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)])); + } + + #[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 }, + ]; + let stored = StoredQueue::new(items, 1, vec![3, 4]).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), &[3, 4]), + Some(stored.clone()) + ); + // A rollback release rewrote queue_json: fall back to it. + assert_eq!(StoredQueue::from_columns(Some(&value), &[3]), None); + let mut future = value.clone(); + future["version"] = serde_json::json!(2); + assert_eq!(StoredQueue::from_columns(Some(&future), &[3, 4]), None); + assert_eq!(StoredQueue::from_columns(None, &[3, 4]), None); + } + + #[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, vec![3, 4]).unwrap(); + stored.retain_library(|id| id != 3, vec![4]); + assert_eq!(stored.items, items[1..].to_vec()); + assert_eq!(stored.position, 0); + assert_eq!(stored.legacy_queue, vec![4]); + + let mut current_removed = StoredQueue::new(items.clone(), 2, vec![3, 4]).unwrap(); + current_removed.retain_library(|id| id != 4, vec![3]); + assert_eq!(current_removed.position, 1); + assert!( + StoredQueue::new( + vec![items[0].clone(); MAX_STORED_QUEUE_ITEMS + 1], + 0, + vec![] + ) + .is_none() + ); + } +} diff --git a/src/player/rows.rs b/src/player/rows.rs index b016a4a..9756048 100644 --- a/src/player/rows.rs +++ b/src/player/rows.rs @@ -65,6 +65,7 @@ pub(super) struct PlaybackStateRow { pub(super) current_track_id: Option, pub(super) position_ms: i32, pub(super) queue_json: String, + pub(super) queue_items_json: Option, pub(super) queue_position: i32, pub(super) shuffle: bool, pub(super) repeat_mode: String, diff --git a/templates/player/scripts.html b/templates/player/scripts.html index c754b49..ad54e8d 100644 --- a/templates/player/scripts.html +++ b/templates/player/scripts.html @@ -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 }}", @@ -857,6 +859,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 +883,17 @@ document.addEventListener('alpine:init', () => { })); return; } + if (this._isUnplayableQueueItem(track)) { + // Podcast episodes stay in the queue; this player skips them. + const playable = this._playableQueueIndex(queue.tracks, idx, idx >= previousIndex ? 1 : -1); + if (playable < 0) { + this._showUnplayableQueueItem(track); + return; + } + queue.currentIndex = playable; + this._playLocal(queue.tracks[playable]); + return; + } this._playLocal(track); }, @@ -900,6 +914,11 @@ document.addEventListener('alpine:init', () => { }, _playLocal(track, options = {}) { + if (this._isUnplayableQueueItem(track)) { + this._recordHistory('replaced'); + this._showUnplayableQueueItem(track); + return; + } this._recordHistory('replaced'); this.currentTrack = track; this._historyTrack = track; @@ -957,6 +976,10 @@ document.addEventListener('alpine:init', () => { this._sendRemote('resume'); return; } + if (this._isUnplayableQueueItem(this.currentTrack)) { + this.next(); + return; + } audio.play().catch(() => {}); }, @@ -1276,6 +1299,11 @@ document.addEventListener('alpine:init', () => { this._remoteStateBaseTime = desiredTime; this._remoteStateReceivedAt = Date.now(); + if (this._isUnplayableQueueItem(track)) { + this._showUnplayableQueueItem(track); + this._updateMediaSession(); + return; + } if (this._localSourceTrackId !== track.id) { this._playLocal(track, { position_seconds: desiredTime, @@ -1386,13 +1414,83 @@ 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; + }, + + _showUnplayableQueueItem(track) { + // 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.currentTime = 0; + this.progress = 0; + this.duration = Number(track?.duration_seconds || 0); + Alpine.store('queue')?.syncCurrentIndexToTrack(track); + }, + + _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 +1534,54 @@ 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)) { + this._showUnplayableQueueItem(currentTrack); + } 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 +1751,7 @@ document.addEventListener('alpine:init', () => { fedInviteInput: '', fedBusy: false, fedError: '', + selectError: '', remoteHintVisible: false, remoteHintDeviceName: '', _remoteHintShown: false, @@ -2008,7 +2155,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; @@ -2330,7 +2482,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) { diff --git a/templates/player/shell.html b/templates/player/shell.html index b762efe..7a14373 100644 --- a/templates/player/shell.html +++ b/templates/player/shell.html @@ -1521,7 +1521,8 @@ + + + + + + +
+

{{ t.player_podcast_found_title }}

+
+ +
+
+
{{ t.player_podcast_found_failed }}