diff --git a/CHANGELOG.md b/CHANGELOG.md index c02cfba..32ce08a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,32 @@ # Changelog +## v0.13.0 — 2026-11-19 + +- Use the shared `music-dht` 0.6 device-sync types and announce device-sync + protocol 4. Podcast operations and snapshot sections from other devices are + kept and relayed; devices below protocol 4 never receive them. +- Keep podcast episodes and other non-library queue items through the web + player, with their explicit source. The player labels and skips them; the + typed queue is stored next to `queue_json` (migrations `m_0054`, `m_0055`). + A handoff through the web player keeps the position of the current episode. +- Refuse a playback transfer of a queue with podcast episodes to a device that + needs an update, and ignore its playback commands while the queue has them. +- Store the protocol version each device reports itself instead of this + server's version; invites carry the inviter's version. +- An episode that the web player selects without knowing its position (Next, + auto-advance, a click) resumes from its synchronized progress on the next + device instead of restarting at 0. Repeat all and shuffle continue past + episodes; Prev and seeking work on them. +- Jam guests see podcast episodes of the host as private items, without their + duration, and cannot add, remove or clear them; the host browser enforces + this on its own queue. Guests do not keep the placeholders after the Jam. +- Metadata Repair can still undo deletions recorded before the typed queue + column was added. +- Rolling back to 0.12 requires removing the relayed podcast operations first; + see "Rolling back to 0.12" in `docs/administration.md`. After a rollback, the + typed queue is used again only if 0.12 left the queue and its current track + unchanged. + ## v0.10.6 — 2026-09-02 - Recover federation automatically after sleep, prolonged idle, or a degraded rendezvous transport. diff --git a/Cargo.lock b/Cargo.lock index 68a93ca..0350402 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1843,8 +1843,7 @@ dependencies = [ [[package]] name = "federation-net" version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "01e5c2e6e5af020dc202d4924125ef57719aa21f8d2567e2d943914386bc8980" +source = "git+https://gt.hexor.cy/Sanapach/frid.git?branch=podcasts%2Fcontract#65d6ca2f14a1324dc129b90694da83ceb55c60dc" dependencies = [ "blake3", "data-encoding", @@ -1988,7 +1987,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" [[package]] name = "furumusic" -version = "0.12.4" +version = "0.13.0" dependencies = [ "anyhow", "async-stream", @@ -3900,9 +3899,8 @@ dependencies = [ [[package]] name = "music-dht" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c3f75d49d3a742a6777a1c4cc53f397399dfc9ddb70034c57aeb44d75d2ee4f" +version = "0.6.0" +source = "git+https://gt.hexor.cy/Sanapach/frid.git?branch=podcasts%2Fcontract#65d6ca2f14a1324dc129b90694da83ceb55c60dc" dependencies = [ "async-trait", "blake3", diff --git a/Cargo.toml b/Cargo.toml index bbc8624..621a935 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "furumusic" -version = "0.12.4" +version = "0.13.0" edition = "2024" description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL" @@ -56,4 +56,8 @@ uuid = "1" librqbit = { version = "8.1.1", features = ["disable-upload"] } # P2P federation: publishes the library into a shared DHT and serves audio / # catalogs to furumi peers (TUI clients) over the frid stack. -music-dht = "0.5.0" +music-dht = "0.6.0" + +[patch.crates-io] +# Unpublished frid (MR-F1); remove once music-dht 0.6.0 is on crates.io. +music-dht = { git = "https://gt.hexor.cy/Sanapach/frid.git", branch = "podcasts/contract" } diff --git a/docs/administration.md b/docs/administration.md index 0b13bc8..1c7e615 100644 --- a/docs/administration.md +++ b/docs/administration.md @@ -71,6 +71,31 @@ Trusted-device pairing is separate from public catalog discovery. It connects a user's own Furumi players so likes, playlists, playback state, and control can move between approved devices. +Queues synchronized from other Furumi players can contain podcast episodes. The +web player keeps them in the queue, in order and with their position, and shows +them as **Podcast · not playable in the web player yet**; local playback skips +them. A device that does not support podcasts yet (device-sync protocol below +4, for example an older terminal player) cannot receive such a queue: selecting +it as the playback device shows that it needs an update, and the episodes stay +in the queue. Jam guests see podcast episodes of the host only as private items. + +### Rolling back to 0.12 + +Release 0.13 relays podcast synchronization operations from other Furumi +players. Release 0.12 cannot read them: device synchronization would fail for +every device that has not received them yet. Before you start a 0.12 release +on a database that 0.13 used, stop the server and remove those operations: + +```sql +DELETE FROM furumusic__fed_sync_ops WHERE kind LIKE 'podcast\_%'; +``` + +Devices that support podcasts keep their own podcast state. The relay table +`furumusic__fed_podcast_relay` and the typed queue column can stay: 0.12 +ignores them, and after the next upgrade 0.13 returns the relayed podcast state +in its snapshots again and uses the typed queue only while it matches the +queue, current track and position that 0.12 saved. + ## Admin statistics The only admin interface is `/admin/v2`, also reachable from `/admin/`. diff --git a/docs/development.md b/docs/development.md index bad10bc..7bb4238 100644 --- a/docs/development.md +++ b/docs/development.md @@ -35,6 +35,51 @@ source code, templates or prompts reuse the dependency layer when its recipe and toolchain are unchanged. Both dependency and application builds use `--locked`. Update the pinned build tools in `Dockerfile`; changing them rebuilds the cache. +## Connected devices and podcast queue items + +Trusted-device sync uses the shared `music_dht::device_sync` types (no local +copies) and announces protocol version 4. The web player has no podcast +features yet, but it keeps every v4 element it receives: + +- podcast operations stay in the operation log and are relayed to v4 devices + only; their registers and the podcast snapshot sections are merged with the + shared `music_dht::podcast` rules into `furumusic__fed_podcast_relay` + (opaque contract JSON) and returned in this server's snapshots; +- queue items that are not library tracks become external browser items + (`source` plus the verbatim `wire_track`), so podcast episodes and Jam + placeholders survive peer → server → browser → server → peer unchanged; +- `furumusic__playback_state.queue_items_json` stores the typed queue next to + `queue_json`. `queue_json` (library ids) is still written for rollback; the + typed value is used only while the legacy columns it recorded + (`queue_json`, `current_track_id`, `queue_position`) match the row. Jam + placeholders are never stored in a user's own queue. +- a browser that selects a podcast episode it cannot play does not know the + episode's position. It reports `position_unknown`, and the server sends the + resume position of the relayed progress register instead of 0. Jam + participant commands carry `jam_participant`; the host browser checks them + against its own queue. + +Rolling back to 0.12 needs the podcast operations removed from the operation +log first; see "Rolling back to 0.12" in `administration.md`. + +Everything sent to a device is gated by the version that device reported itself +(`profile_protocol_version`; relayed profiles only raise it). See the podcast +contract (`PODCASTS.md`) and `PLAYBACK_PROTOCOL.md` in the Frid repository. + +```bash +cargo test devices:: queue_items podcast_relay queue_persistence +node --test tests/player_queue_sources.test.cjs +# Migrated disposable PostgreSQL (start the server against it once): +FURU_DEVICE_SYNC_TEST_DATABASE_URL=postgresql://... \ + cargo test devices::postgres_tests -- --ignored +FURU_METADATA_FIX_TEST_DATABASE_URL=postgresql://... \ + cargo test undo_accepts_playback_archives_written_before_the_typed_queue -- --ignored +``` + +`wire_compat_tests` compares the shared types with the private copies of +0.12.x byte for byte; `fixtures/v3_hello.golden.json` is the v3 shape. Rewrite +it only for a deliberate change, with `FURUMUSIC_BLESS_GOLDEN=1`. + ## Contributing Bug reports, design discussions, and patches are welcome. Before submitting a diff --git a/src/admin/metadata_fix.rs b/src/admin/metadata_fix.rs index 80c1b3b..33b4954 100644 --- a/src/admin/metadata_fix.rs +++ b/src/admin/metadata_fix.rs @@ -1438,18 +1438,28 @@ 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", + // (id, current_track_id, queue_json, queue_items_json, queue_position) + type QueueRow = (i64, Option, String, Option, i32); + let states: Vec = sqlx::query_as( + "SELECT id,current_track_id,queue_json,queue_items_json,queue_position FROM furumusic__playback_state FOR UPDATE", ) .fetch_all(&mut *conn) .await?; - for (id, current, queue_json) in states { + for (id, current, queue_json, queue_items_json, queue_position) in states { let mut queue: Vec = serde_json::from_str(&queue_json).unwrap_or_default(); if !current.is_some_and(|id| deleted.tracks.contains(&id)) && !queue.iter().any(|id| deleted.tracks.contains(id)) { continue; } + let mut typed = crate::player::queue_items::StoredQueue::from_columns( + queue_items_json.as_ref(), + &crate::player::queue_items::LegacyColumns { + queue: queue.clone(), + current_track_id: current, + queue_position, + }, + ); let before: String = sqlx::query_scalar( "SELECT to_jsonb(t)::text FROM furumusic__playback_state t WHERE id=$1", ) @@ -1461,8 +1471,19 @@ async fn delete_entities( let position = current .and_then(|id| queue.iter().position(|x| *x == id)) .unwrap_or(0) as i32; - let after: String = sqlx::query_scalar("UPDATE furumusic__playback_state SET current_track_id=$2,queue_json=$3,queue_position=$4,position_ms=CASE WHEN current_track_id IS DISTINCT FROM $2 THEN 0 ELSE position_ms END WHERE id=$1 RETURNING to_jsonb(furumusic__playback_state)::text") - .bind(id).bind(current).bind(serde_json::to_string(&queue)?).bind(position).fetch_one(&mut *conn).await?; + if let Some(typed) = &mut typed { + typed.retain_library( + |id| !deleted.tracks.contains(&id), + crate::player::queue_items::LegacyColumns { + queue: queue.clone(), + current_track_id: current, + queue_position: position, + }, + ); + } + let queue_items_json = typed.map(serde_json::to_value).transpose()?; + let after: String = sqlx::query_scalar("UPDATE furumusic__playback_state SET current_track_id=$2,queue_json=$3,queue_position=$4,queue_items_json=$5,position_ms=CASE WHEN current_track_id IS DISTINCT FROM $2 THEN 0 ELSE position_ms END WHERE id=$1 RETURNING to_jsonb(furumusic__playback_state)::text") + .bind(id).bind(current).bind(serde_json::to_string(&queue)?).bind(position).bind(queue_items_json).fetch_one(&mut *conn).await?; archived.push(ArchivedRows { table: "furumusic__playback_state".into(), rows: serde_json::json!([serde_json::from_str::(&before)?]), @@ -1502,6 +1523,7 @@ async fn restore_deleted(conn: &mut PgConnection, archived: &[ArchivedRows]) -> &[ "current_track_id", "queue_json", + "queue_items_json", "queue_position", "position_ms", ] @@ -1515,7 +1537,9 @@ async fn restore_deleted(conn: &mut PgConnection, archived: &[ArchivedRows]) -> }) .collect::>() .join(","); - let affected = sqlx::query(&format!("UPDATE {table} t SET {assignments} FROM jsonb_array_elements($1::jsonb) WITH ORDINALITY b(value,n) JOIN jsonb_array_elements($2::jsonb) WITH ORDINALITY a(value,n) USING(n) WHERE to_jsonb(t)=a.value")) + // Archives written before m_0054 have no `queue_items_json` key; + // compare them without the column added since. + let affected = sqlx::query(&format!("UPDATE {table} t SET {assignments} FROM jsonb_array_elements($1::jsonb) WITH ORDINALITY b(value,n) JOIN jsonb_array_elements($2::jsonb) WITH ORDINALITY a(value,n) USING(n) WHERE (CASE WHEN a.value ? 'queue_items_json' THEN to_jsonb(t) ELSE to_jsonb(t) - 'queue_items_json' END)=a.value")) .bind(entry.rows.to_string()).bind(after.to_string()).execute(&mut *conn).await?.rows_affected(); anyhow::ensure!( affected as usize == after.as_array().map_or(0, Vec::len), @@ -1804,6 +1828,51 @@ pub(super) async fn undo( mod tests { use super::*; + #[tokio::test] + #[ignore = "requires a migrated disposable database in FURU_METADATA_FIX_TEST_DATABASE_URL"] + async fn undo_accepts_playback_archives_written_before_the_typed_queue() { + let pool = + sqlx::PgPool::connect(&std::env::var("FURU_METADATA_FIX_TEST_DATABASE_URL").unwrap()) + .await + .unwrap(); + let mut tx = pool.begin().await.unwrap(); + let user_id = 9_000_000_000 + i64::from(std::process::id()); + // State after the deletion, read back like an archive written by 0.12 + // (`to_jsonb` of the row before m_0054 added `queue_items_json`). + let after: serde_json::Value = sqlx::query_scalar( + "INSERT INTO furumusic__playback_state (user_id,current_track_id,position_ms,queue_json,queue_position,shuffle,repeat_mode,volume,updated_at) VALUES ($1,NULL,0,'[]',0,false,'off',0.7,'now') RETURNING to_jsonb(furumusic__playback_state) - 'queue_items_json'", + ) + .bind(user_id) + .fetch_one(&mut *tx) + .await + .unwrap(); + let mut before = after.clone(); + before["queue_json"] = serde_json::json!("[123456789]"); + before["position_ms"] = serde_json::json!(5000); + let archive = ArchivedRows { + table: "furumusic__playback_state".into(), + rows: serde_json::json!([before]), + after: Some(serde_json::json!([after])), + }; + restore_deleted(&mut tx, std::slice::from_ref(&archive)) + .await + .unwrap(); + let (queue_json, position_ms, typed): (String, i32, Option) = + sqlx::query_as( + "SELECT queue_json,position_ms,queue_items_json FROM furumusic__playback_state WHERE user_id=$1", + ) + .bind(user_id) + .fetch_one(&mut *tx) + .await + .unwrap(); + assert_eq!(queue_json, "[123456789]"); + assert_eq!(position_ms, 5000); + assert_eq!(typed, None); + // A row changed since the deletion is still refused. + assert!(restore_deleted(&mut tx, &[archive]).await.is_err()); + tx.rollback().await.unwrap(); + } + fn snapshot() -> Snapshot { Snapshot { artists: vec![ArtistState { diff --git a/src/federation/devices.rs b/src/federation/devices.rs index 125aa4f..e7db3dd 100644 --- a/src/federation/devices.rs +++ b/src/federation/devices.rs @@ -1,40 +1,69 @@ //! 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, PlaybackSource, + 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::podcast::ProgressRecord; 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 +123,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 +159,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 +245,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 +271,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 +905,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 +950,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 +969,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 +1183,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 +1203,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 +1223,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 +1273,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 +1313,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 +1348,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 +1385,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 +1693,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 +1725,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 +1804,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 +1830,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 +1852,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 +1981,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 +2030,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 +2407,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 +2490,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 +2570,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 +2616,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 +2721,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(()); }; @@ -3007,8 +2895,15 @@ pub async fn record_web_playback_command( current_state: Option, ) -> Result { 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?; + let mut next_state = browser_state_for_command(command, payload, current_state)?; + let wire = playback_state_from_browser_json(pool, user_id, next_state.clone()).await?; + // Show the resume position that was sent, not the 0 the browser picked. + if let Some(object) = next_state.as_object_mut() + && object.remove(queue_items::POSITION_UNKNOWN_KEY).is_some() + { + object.insert("position_seconds".to_string(), json_f64(wire.position_secs)); + } + ensure_playback_supported_by(pool, user_id, target_device_id, &wire).await?; record_local_op( pool, user_id, @@ -3036,7 +2931,9 @@ pub async fn record_web_active_transfer( state: serde_json::Value, ) -> Result<()> { ensure_web_playback_target(pool, user_id, target_device_id).await?; - let wire = playback_state_from_browser_json(pool, state).await?; + let wire = playback_state_from_browser_json(pool, user_id, 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 +2978,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, user_id, 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, @@ -3089,7 +2997,7 @@ pub async fn record_web_active_takeover( ) -> Result<()> { ensure_web_playback_target(pool, user_id, previous_device_id).await?; let identity = ensure_identity(pool, user_id, "").await?; - let wire = playback_state_from_browser_json(pool, state).await?; + let wire = playback_state_from_browser_json(pool, user_id, state).await?; with_playback_engine(pool, user_id, &identity, |engine| { engine.transfer(&identity.device_id, playback_clock()) }) @@ -3111,6 +3019,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, @@ -3166,6 +3096,11 @@ fn browser_state_for_command( current_state.unwrap_or_else(empty_browser_playback_state) }; normalize_browser_playback_state(&mut state); + // Only a transfer carries the sender's knowledge of the position; the + // commands below decide for themselves. + if command != "transfer_state" { + browser_object_mut(&mut state).remove(queue_items::POSITION_UNKNOWN_KEY); + } match command { "play_track" | "play_from_index" | "transfer_state" => { @@ -3175,6 +3110,11 @@ fn browser_state_for_command( "paused", browser_bool(&payload, "paused").unwrap_or(false), ); + if command != "transfer_state" { + // The browser always starts the item at 0. For a podcast + // episode, ordinary Play resumes from its progress register. + mark_browser_position_unknown(&mut state); + } } "pause" => set_browser_bool(&mut state, "paused", true), "resume" => { @@ -3392,11 +3332,20 @@ fn advance_browser_state(state: &mut serde_json::Value, payload: &serde_json::Va set_browser_tracks(state, tracks, next); set_browser_number(state, "position_seconds", 0.0); set_browser_bool(state, "paused", false); + if next != current { + mark_browser_position_unknown(state); + } } else { set_browser_bool(state, "paused", true); } } +/// The current item changed without its position: a podcast episode resumes +/// from its progress register (see `playback_state_from_browser_json`). +fn mark_browser_position_unknown(state: &mut serde_json::Value) { + set_browser_bool(state, queue_items::POSITION_UNKNOWN_KEY, true); +} + fn rewind_browser_state(state: &mut serde_json::Value) { let tracks = browser_tracks(state); if tracks.is_empty() { @@ -3427,6 +3376,9 @@ fn rewind_browser_state(state: &mut serde_json::Value) { if let Some(previous) = previous { set_browser_tracks(state, tracks, previous); set_browser_bool(state, "paused", false); + if previous != current { + mark_browser_position_unknown(state); + } } set_browser_number(state, "position_seconds", 0.0); } @@ -3554,11 +3506,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 @@ -3570,7 +3525,12 @@ async fn local_playback_snapshot( let state = hub .playback_state_json_for_commands(user_id) .unwrap_or_else(|| serde_json::json!({})); - let wire = playback_state_from_browser_json(pool, state).await.ok()?; + let wire = playback_state_from_browser_json(pool, user_id, 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(), @@ -3694,7 +3654,56 @@ fn playback_clock() -> u64 { .as_millis() as u64 } +/// Wire playback state of a browser state. +/// +/// When the browser does not know the position of its current item +/// ([`queue_items::POSITION_UNKNOWN_KEY`]) and that item is a podcast +/// episode, the position comes from the relayed progress register: handing +/// 0 to the next device would be written there as an explicit action and +/// restart the episode everywhere. async fn playback_state_from_browser_json( + pool: &sqlx::PgPool, + user_id: i64, + state: serde_json::Value, +) -> Result { + let unknown = browser_bool(&state, queue_items::POSITION_UNKNOWN_KEY) == Some(true); + let mut wire = browser_json_to_wire(pool, state).await?; + if unknown + && let Some(episode) = wire + .queue + .get(wire.queue_pos) + .and_then(PlaybackTrack::podcast_episode_ref) + { + let record = + podcast_relay::progress_record(pool, user_id, episode.episode_id.as_str()).await?; + apply_resume_position(&mut wire, record.as_ref()); + } + Ok(wire) +} + +/// Sets the position of the current podcast episode to where ordinary Play +/// resumes it (`ProgressRecord::resume_position_ms`, 0 without a register), +/// and records the register's generation as seen for the handoff. +fn apply_resume_position(state: &mut PlaybackStateWire, record: Option<&ProgressRecord>) { + let Some(track) = state.queue.get_mut(state.queue_pos) else { + return; + }; + let Some(PlaybackSource::PodcastEpisode(episode)) = track.source.as_mut() else { + return; + }; + let Some(record) = record.filter(|record| record.episode_id == episode.episode_id) else { + state.position_secs = 0.0; + return; + }; + state.position_secs = record.resume_position_ms().max(0) as f64 / 1000.0; + episode.progress_generation = Some( + episode + .progress_generation + .map_or(record.generation, |seen| seen.max(record.generation)), + ); +} + +async fn browser_json_to_wire( pool: &sqlx::PgPool, state: serde_json::Value, ) -> Result { @@ -3703,19 +3712,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 +3763,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 +3773,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 +3817,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 +3839,7 @@ async fn playback_track_from_track_json( .and_then(serde_json::Value::as_i64), play_count: 0, fed: None, + source: None, }) } @@ -3836,31 +3857,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 +4002,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 +4434,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 +4467,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 +4475,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 +4582,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 +4823,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 +4837,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 +4921,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 +4967,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..f04ca82 --- /dev/null +++ b/src/federation/devices/gating_tests.rs @@ -0,0 +1,575 @@ +//! Version gating and lossless queue bridge (device-sync protocol v4). + +use super::*; +use crate::player::queue_items::{self, test_episode}; +use music_dht::podcast::{ + EpisodeId, FeedUrl, ListenSession, PodcastId, PodcastMeta, ProgressStatus, +}; + +const CONTENT_ID: &str = "b3:2222222222222222222222222222222222222222222222222222222222222222"; + +fn podcast_id() -> PodcastId { + PodcastId::from_feed_url(&FeedUrl::parse("https://podcasts.example/feed.xml").unwrap()) +} + +fn episode_id() -> EpisodeId { + EpisodeId::from_guid(&podcast_id(), "ep-1").unwrap() +} + +fn music_track(id: i64) -> PlaybackTrack { + let mut track = PlaybackTrack::private_placeholder(); + track.source = None; + track.id = id; + track.title = format!("Song {id}"); + track +} + +fn state(queue: Vec) -> 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; + incoming.position_secs = 1200.0; + + // peer -> server -> browser + let payload = web_playback_payload(&pool, &incoming).await.unwrap(); + let tracks = payload["tracks"].as_array().unwrap(); + assert_eq!(tracks.len(), 4, "no item is dropped"); + assert_eq!(payload["index"], 3); + assert_eq!(payload["position_seconds"], 1200.0); + assert_eq!(tracks[0]["source"]["kind"], "podcast_episode"); + assert_eq!(tracks[0]["unavailable"], true); + assert_eq!(tracks[1]["source"]["kind"], "private"); + + // The browser keeps its queue and sends it back (plus a library track + // it added at the end, with its content id inline). + let mut browser: serde_json::Value = serde_json::from_str(&payload.to_string()).unwrap(); + browser["tracks"] + .as_array_mut() + .unwrap() + .push(serde_json::json!({ + "id": 77, "title": "Library song", "content_id": CONTENT_ID, + "duration_seconds": 100.0, "artists": [{"id": 1, "name": "A"}], + "release_id": 9, "release_title": "Album", + })); + + // browser -> server -> peer + let outgoing = playback_state_from_browser_json(&pool, 1, browser) + .await + .unwrap(); + assert_eq!(outgoing.queue[..4], queue[..]); + assert_eq!(outgoing.queue_pos, 3); + assert!(outgoing.paused); + // The episode position goes back to the peer (handoff web -> TUI). + assert_eq!(outgoing.position_secs, 1200.0); + let library = &outgoing.queue[4]; + assert_eq!(library.id, 77); + assert_eq!(library.content_id.as_deref(), Some(CONTENT_ID)); + assert_eq!(library.source, None); + // Library music keeps the v3 shape. + assert!(!serde_json::to_string(library).unwrap().contains("source")); + // Peers below v4 get no playback snapshot with these items. + assert!(!playback_allowed_for_peer(&outgoing, 3)); + assert!(playback_allowed_for_peer(&outgoing, 4)); +} + +#[tokio::test] +async fn malformed_browser_items_keep_the_position_on_its_item() { + let pool = offline_pool(); + let browser = serde_json::json!({ + "tracks": [ + {"title": "no id"}, + {"id": 5, "content_id": CONTENT_ID}, + {"id": 6, "content_id": CONTENT_ID}, + ], + "index": 2, + "track": {"id": 6}, + }); + let wire = playback_state_from_browser_json(&pool, 1, browser) + .await + .unwrap(); + assert_eq!(wire.queue.len(), 2); + assert_eq!(wire.queue[wire.queue_pos].id, 6); +} + +fn progress_record(position_ms: i64, status: ProgressStatus, generation: u64) -> ProgressRecord { + let episode = test_episode(); + ProgressRecord { + episode_id: episode.episode_id, + podcast_id: episode.podcast_id, + position_ms, + status, + generation, + session_id: "session-1".into(), + hlc_ms: 1_700_000_000_000, + device_id: "tui".into(), + op_id: "op-1".into(), + } +} + +/// Browser state of `[library song, episode]` with the song current at 200 s. +fn song_then_episode() -> serde_json::Value { + let episode = PlaybackTrack::podcast_episode(test_episode()); + let song = serde_json::json!({ + "id": 77, "title": "Library song", "content_id": CONTENT_ID, + "duration_seconds": 300.0, "stream_url": "/api/player/stream/77", + }); + serde_json::json!({ + "tracks": [song.clone(), queue_items::external_track_json(&episode, 1, None)], + "index": 0, + "track": song, + "position_seconds": 200.0, + "paused": false, + "repeat_mode": "off", + }) +} + +fn position_unknown(state: &serde_json::Value) -> bool { + state[queue_items::POSITION_UNKNOWN_KEY] == true +} + +#[test] +fn commands_that_select_an_item_do_not_know_its_position() { + let current = song_then_episode(); + // Next and Prev onto another item, and play commands (which the browser + // always sends with position 0), leave the position to the server. + let next = + browser_state_for_command("next", serde_json::json!({}), Some(current.clone())).unwrap(); + assert_eq!(next["index"], 1); + assert_eq!(next["position_seconds"], 0.0); + assert!(position_unknown(&next)); + let mut play = current.clone(); + play["index"] = serde_json::json!(1); + let played = browser_state_for_command("play_from_index", play.clone(), None).unwrap(); + assert!(position_unknown(&played)); + let prev = + browser_state_for_command("prev", serde_json::json!({}), Some(next.clone())).unwrap(); + assert_eq!(prev["index"], 0); + assert!(position_unknown(&prev)); + + // Restarting the same item and seeking are explicit positions. + let mut late = next.clone(); + late["position_seconds"] = serde_json::json!(900.0); + let restart = browser_state_for_command("prev", serde_json::json!({}), Some(late)).unwrap(); + assert_eq!(restart["index"], 1); + assert!(!position_unknown(&restart)); + let repeat = browser_state_for_command( + "next", + serde_json::json!({"repeat_mode": "one"}), + Some(next.clone()), + ) + .unwrap(); + assert!(!position_unknown(&repeat)); + let seek = + browser_state_for_command("seek", serde_json::json!({"time": 60.0}), Some(next)).unwrap(); + assert_eq!(seek["position_seconds"], 60.0); + assert!(!position_unknown(&seek)); + + // A transfer keeps what the sender knew. + let mut handed_off = play; + handed_off["position_seconds"] = serde_json::json!(1200.0); + let transfer = browser_state_for_command("transfer_state", handed_off.clone(), None).unwrap(); + assert_eq!(transfer["position_seconds"], 1200.0); + assert!(!position_unknown(&transfer)); + handed_off[queue_items::POSITION_UNKNOWN_KEY] = serde_json::json!(true); + let transfer = browser_state_for_command("transfer_state", handed_off, None).unwrap(); + assert!(position_unknown(&transfer)); +} + +#[tokio::test] +async fn unknown_episode_position_resumes_from_the_progress_register() { + let pool = offline_pool(); + let next = browser_state_for_command("next", serde_json::json!({}), Some(song_then_episode())) + .unwrap(); + let mut wire = browser_json_to_wire(&pool, next).await.unwrap(); + assert_eq!(wire.queue_pos, 1); + assert_eq!(wire.position_secs, 0.0); + + // In progress at 1200 s, generation 9 (the queue item has seen 7). + let mut resumed = wire.clone(); + apply_resume_position( + &mut resumed, + Some(&progress_record(1_200_000, ProgressStatus::InProgress, 9)), + ); + assert_eq!(resumed.position_secs, 1200.0); + let episode = resumed.queue[1].podcast_episode_ref().unwrap(); + assert_eq!(episode.progress_generation, Some(9)); + // The receiver's explicit write then orders after the register. + assert_eq!( + ProgressRecord::explicit_generation(episode.progress_generation), + 10 + ); + + // Completed: ordinary Play starts from the beginning; an older register + // does not lower the generation the item has seen. + let mut completed = wire.clone(); + apply_resume_position( + &mut completed, + Some(&progress_record(1_790_000, ProgressStatus::Completed, 3)), + ); + assert_eq!(completed.position_secs, 0.0); + assert_eq!( + completed.queue[1] + .podcast_episode_ref() + .unwrap() + .progress_generation, + Some(7) + ); + + // Music keeps the position it has. + wire.queue_pos = 0; + wire.position_secs = 5.0; + let before = wire.clone(); + apply_resume_position( + &mut wire, + Some(&progress_record(1_200_000, ProgressStatus::InProgress, 9)), + ); + assert_eq!(wire, before); +} + +#[tokio::test] +async fn known_positions_and_music_never_read_the_progress_register() { + // The offline pool fails any query, so these conversions must not query. + let pool = offline_pool(); + let mut handed_off = song_then_episode(); + handed_off["index"] = serde_json::json!(1); + handed_off["position_seconds"] = serde_json::json!(1200.0); + let wire = playback_state_from_browser_json(&pool, 1, handed_off) + .await + .unwrap(); + assert_eq!(wire.position_secs, 1200.0); + + let mut music = song_then_episode(); + music[queue_items::POSITION_UNKNOWN_KEY] = serde_json::json!(true); + let wire = playback_state_from_browser_json(&pool, 1, music) + .await + .unwrap(); + assert_eq!(wire.position_secs, 200.0); +} 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..4d50f56 --- /dev/null +++ b/src/federation/devices/postgres_tests.rs @@ -0,0 +1,478 @@ +//! Device-sync v4 storage paths against PostgreSQL. +//! +//! Requires a migrated disposable database (start the server once against +//! it); the test writes rows for a random user id and removes them again. + +use super::*; +use crate::player::queue_items::test_episode; +use music_dht::podcast::{ + EpisodeId, FeedUrl, PodcastId, PodcastMeta, ProgressRecord, ProgressStatus, ShareRecord, +}; + +fn profile(device_id: &str, protocol_version: u16) -> DeviceProfileWire { + DeviceProfileWire { + device_id: device_id.into(), + name: device_id.to_uppercase(), + client_version: "test".into(), + protocol_version, + endpoint_id: String::new(), + endpoint_ticket: String::new(), + revoked: false, + revoke_cutoff_seq: None, + updated_at_ms: now_ms(), + } +} + +fn op(origin: &str, seq: i64, hlc_ms: i64, payload: SyncOpPayload) -> SyncOpWire { + SyncOpWire { + op_id: format!("{origin}:{seq}"), + origin_device_id: origin.into(), + seq, + hlc_ms, + payload, + } +} + +async fn cleanup(pool: &sqlx::PgPool, user_id: i64) { + for table in [ + "furumusic__fed_device_identity", + "furumusic__fed_device", + "furumusic__fed_device_invite", + "furumusic__fed_peer_ack", + "furumusic__fed_pending_pairing", + "furumusic__fed_playback_applied", + "furumusic__fed_podcast_relay", + "furumusic__fed_state_like", + "furumusic__fed_state_playlist", + "furumusic__fed_state_playlist_item", + "furumusic__fed_sync_ops", + "furumusic__fed_sync_vector", + "furumusic__playback_state", + ] { + sqlx::query(&format!("DELETE FROM {table} WHERE user_id = $1")) + .bind(user_id) + .execute(pool) + .await + .unwrap(); + } +} + +#[tokio::test] +#[ignore = "requires a migrated disposable database in FURU_DEVICE_SYNC_TEST_DATABASE_URL"] +async fn postgres_podcast_relay_gating_and_peer_versions() { + let pool = sqlx::PgPool::connect(&std::env::var("FURU_DEVICE_SYNC_TEST_DATABASE_URL").unwrap()) + .await + .unwrap(); + let user_id = 8_000_000_000 + i64::from(rand_suffix()); + cleanup(&pool, user_id).await; + let new = format!("tui_new_{user_id}"); + let old = format!("tui_old_{user_id}"); + let other = format!("tui_other_{user_id}"); + let identity = ensure_identity(&pool, user_id, "tester").await.unwrap(); + + // Peer versions: self-reports replace, relayed profiles only raise. + for (device, version) in [(&new, 4), (&old, 3), (&other, 4)] { + apply_device_profile( + &pool, + user_id, + &profile(device, version), + VersionReport::SelfReported(Some(version)), + true, + ) + .await + .unwrap(); + } + // A v3 relay lists everyone with its own constant. + apply_device_profiles( + &pool, + user_id, + &[profile(&new, 3), profile(&old, 3)], + Some(old.as_str()), + ) + .await + .unwrap(); + assert_eq!( + stored_protocol_version(&pool, user_id, &new).await.unwrap(), + 4 + ); + assert_eq!( + stored_protocol_version(&pool, user_id, &old).await.unwrap(), + 3 + ); + + // Podcast and music operations from the v4 device. + let feed = FeedUrl::parse("https://podcasts.example/feed.xml").unwrap(); + let podcast_id = PodcastId::from_feed_url(&feed); + let episode_id = EpisodeId::from_guid(&podcast_id, "ep-1").unwrap(); + let meta: PodcastMeta = serde_json::from_value(serde_json::json!({ + "feed_url": feed.as_str(), "title": "Example Cast" + })) + .unwrap(); + let progress = |seq, generation, hlc_ms, position_ms| { + op( + &new, + seq, + hlc_ms, + SyncOpPayload::PodcastProgressSet { + episode_id: episode_id.clone(), + podcast_id: podcast_id.clone(), + position_ms, + status: ProgressStatus::InProgress, + generation, + session_id: format!("s{generation}"), + episode: None, + }, + ) + }; + let mut invalid = progress(5, 9, 50, 1); + if let SyncOpPayload::PodcastProgressSet { session_id, .. } = &mut invalid.payload { + session_id.clear(); + } + let hub = Arc::new(PlayerDeviceHub::default()); + apply_ops( + &pool, + Arc::clone(&hub), + user_id, + vec![ + op( + &new, + 1, + 10, + SyncOpPayload::PodcastSubscriptionSet { + podcast_id: podcast_id.clone(), + subscribed: true, + podcast: meta, + feed_aliases: vec![], + generation: 1, + }, + ), + // Newer generation first, then a late checkpoint of an older one. + progress(2, 4, 20, 10_000), + progress(3, 3, 90_000, 600_000), + op( + &new, + 4, + 40, + SyncOpPayload::TrackLikeSet { + content_id: format!("b3:{}", "3".repeat(64)), + liked: false, + fed: None, + }, + ), + invalid, + ], + ) + .await + .unwrap(); + // The invalid operation is not stored but acknowledged. + assert_eq!(vector(&pool, user_id).await.unwrap().get(&new), Some(&5)); + let stored: i64 = sqlx::query_scalar( + "SELECT COUNT(*) FROM furumusic__fed_sync_ops WHERE user_id = $1 AND origin_device_id = $2", + ) + .bind(user_id) + .bind(&new) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(stored, 4); + + // Relay: the v3 peer gets only music, a v4 peer gets everything. + let kinds = |ops: Vec| { + 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; +} + +#[tokio::test] +#[ignore = "requires a migrated disposable database in FURU_DEVICE_SYNC_TEST_DATABASE_URL"] +async fn postgres_unknown_episode_position_and_rollback_cleanup() { + let pool = sqlx::PgPool::connect(&std::env::var("FURU_DEVICE_SYNC_TEST_DATABASE_URL").unwrap()) + .await + .unwrap(); + let user_id = 8_000_000_000 + i64::from(rand_suffix()); + cleanup(&pool, user_id).await; + let tui = format!("tui_{user_id}"); + ensure_identity(&pool, user_id, "tester").await.unwrap(); + apply_device_profile( + &pool, + user_id, + &profile(&tui, 4), + VersionReport::SelfReported(Some(4)), + true, + ) + .await + .unwrap(); + + // The TUI left the episode at 1200 s (generation 9; queue items saw 7). + let episode = test_episode(); + let hub = Arc::new(PlayerDeviceHub::default()); + apply_ops( + &pool, + Arc::clone(&hub), + user_id, + vec![op( + &tui, + 1, + 10, + SyncOpPayload::PodcastProgressSet { + episode_id: episode.episode_id.clone(), + podcast_id: episode.podcast_id.clone(), + position_ms: 1_200_000, + status: ProgressStatus::InProgress, + generation: 9, + session_id: "s9".into(), + episode: None, + }, + )], + ) + .await + .unwrap(); + + // The web player reached the episode by Next and does not know where it + // was left; it hands playback to the TUI. + let song = serde_json::json!({ + "id": 77, "title": "Library song", "content_id": format!("b3:{}", "4".repeat(64)), + "duration_seconds": 300.0, + }); + let item = crate::player::queue_items::external_track_json( + &PlaybackTrack::podcast_episode(episode.clone()), + 1, + None, + ); + let browser = serde_json::json!({ + "tracks": [song.clone(), item.clone()], "index": 1, "track": item.clone(), + "position_seconds": 0.0, "paused": true, "position_unknown": true, + }); + record_web_active_transfer(&pool, user_id, &tui, None, browser) + .await + .unwrap(); + let sent: serde_json::Value = sqlx::query_scalar( + "SELECT payload_json FROM furumusic__fed_sync_ops + WHERE user_id = $1 AND kind = 'playback_command' ORDER BY seq DESC LIMIT 1", + ) + .bind(user_id) + .fetch_one(&pool) + .await + .unwrap(); + let SyncOpPayload::PlaybackCommand { + command: PlaybackCommand::ActiveChanged { state, .. }, + .. + } = serde_json::from_value(sent).unwrap() + else { + panic!("expected ActiveChanged"); + }; + assert_eq!(state.position_secs, 1200.0, "never 0"); + assert_eq!( + state.queue[1] + .podcast_episode_ref() + .unwrap() + .progress_generation, + Some(9) + ); + + // Remote Next onto the episode while the TUI plays the song. + let current = serde_json::json!({ + "tracks": [song, item], "index": 0, "track": song, + "position_seconds": 200.0, "paused": false, + }); + let next = record_web_playback_command( + &pool, + user_id, + &tui, + "next", + serde_json::json!({}), + Some(current), + ) + .await + .unwrap(); + assert_eq!(next["index"], 1); + assert_eq!(next["position_seconds"], 1200.0); + assert!( + next.get(crate::player::queue_items::POSITION_UNKNOWN_KEY) + .is_none() + ); + + // Rollback to 0.12: its types fail on the relayed podcast operation, and + // parse everything once the documented cleanup ran. + let parse_like_0_12 = |rows: Vec| { + rows.into_iter() + .map(serde_json::from_value::) + .collect::, _>>() + }; + let rows = || async { + sqlx::query_scalar::<_, serde_json::Value>( + "SELECT payload_json FROM furumusic__fed_sync_ops WHERE user_id = $1", + ) + .bind(user_id) + .fetch_all(&pool) + .await + .unwrap() + }; + assert!(parse_like_0_12(rows().await).is_err()); + sqlx::query(&format!( + "{} AND user_id = $1", + crate::music::db_migrations::DELETE_PODCAST_SYNC_OPS_SQL + )) + .bind(user_id) + .execute(&pool) + .await + .unwrap(); + let remaining = parse_like_0_12(rows().await).unwrap(); + // The playback commands (with the episode's `source`) stay readable. + assert_eq!( + remaining + .iter() + .filter(|payload| matches!( + payload, + super::wire_compat_tests::legacy::SyncOpPayload::PlaybackCommand { .. } + )) + .count(), + 2 + ); + + cleanup(&pool, user_id).await; +} + +fn rand_suffix() -> u32 { + u32::from_le_bytes( + blake3::hash(random_hex(8).as_bytes()).as_bytes()[..4] + .try_into() + .unwrap(), + ) % 1_000_000_000 +} diff --git a/src/federation/devices/wire_compat_tests.rs b/src/federation/devices/wire_compat_tests.rs new file mode 100644 index 0000000..36f7ac8 --- /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)] +pub(super) mod legacy { + use music_dht::device_sync::ListenEvent; + use music_dht::playback::CommandStamp; + use serde::{Deserialize, Serialize}; + use std::collections::BTreeMap; + + #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] + pub struct InviteWire { + pub v: u16, + #[serde(rename = "t")] + pub ticket: String, + #[serde(rename = "d")] + pub device_id: String, + #[serde(rename = "i")] + pub invite_id: String, + #[serde(rename = "s")] + pub secret: String, + #[serde(rename = "e")] + pub expires_at_ms: i64, + } + + #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] + pub struct DeviceProfileWire { + pub device_id: String, + pub name: String, + pub client_version: String, + pub protocol_version: u16, + pub endpoint_id: String, + pub endpoint_ticket: String, + #[serde(default)] + pub revoked: bool, + #[serde(default)] + pub revoke_cutoff_seq: Option, + #[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..ff28736 --- /dev/null +++ b/src/federation/podcast_relay.rs @@ -0,0 +1,575 @@ +//! Lossless relay of podcast sync state (device-sync protocol v4). +//! +//! The web server does not implement podcasts yet, but it announces protocol +//! v4 and therefore must not lose podcast state that trusted devices send +//! through it: +//! +//! * podcast operations are stored verbatim in the generic operation log +//! (`furumusic__fed_sync_ops`) and forwarded to v4 peers only; +//! * the podcast registers carried by those operations and by snapshot +//! sections are kept here as opaque JSON documents, merged with the shared +//! `music_dht::podcast` rules, and returned in this device's snapshots. +//! Snapshots are the only recovery path for a peer that skipped podcast +//! operations while it ran an older version. +//! +//! The rows hold the shared contract types (`SubscriptionRecord`, +//! `ShareRecord`, `ProgressRecord`, `ListenSession`) as JSON and nothing +//! web-specific; a later podcast store can import them. + +use anyhow::Result; +use music_dht::device_sync::{SyncOpWire, SyncSnapshot}; +use music_dht::podcast::{ + FeedUrl, ListenSession, PodcastId, ProgressRecord, ShareRecord, SubscriptionRecord, + merge_feed_aliases, merge_listen_session, merge_progress, merge_share, merge_subscription, +}; +use serde::Serialize; +use serde::de::DeserializeOwned; +use serde_json::Value; +use sqlx::Row; + +const SECTION_SUBSCRIPTION: &str = "subscription"; +const SECTION_SHARE: &str = "share"; +const SECTION_ALIASES: &str = "aliases"; +const SECTION_PROGRESS: &str = "progress"; +const SECTION_SESSION: &str = "session"; + +/// One podcast register update, keyed by its entity. +#[derive(Debug, Clone, PartialEq)] +pub(crate) enum RelayRecord { + /// Subscription register of a podcast. + Subscription(SubscriptionRecord), + /// Share register of a podcast. + Share(ShareRecord), + /// Feed aliases learned before (or without) the subscription register. + Aliases(PodcastId, Vec), + /// 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(()) +} + +/// Relayed progress register of an episode, if any. +pub(crate) async fn progress_record( + pool: &sqlx::PgPool, + user_id: i64, + episode_id: &str, +) -> Result> { + let value: Option = sqlx::query_scalar( + "SELECT record_json FROM furumusic__fed_podcast_relay + WHERE user_id = $1 AND section = $2 AND record_key = $3", + ) + .bind(user_id) + .bind(SECTION_PROGRESS) + .bind(episode_id) + .fetch_optional(pool) + .await?; + Ok(value.as_ref().and_then(parse)) +} + +/// Adds the relayed podcast registers to `snapshot`. +/// +/// The sections are bounded later, per message, with the contract budget +/// (`SyncSnapshot::bound_podcast_state_to`) and stripped for peers below v4 +/// (`SyncSnapshot::for_peer`). +pub(crate) async fn fill_snapshot( + pool: &sqlx::PgPool, + user_id: i64, + snapshot: &mut SyncSnapshot, +) -> Result<()> { + let rows = sqlx::query( + "SELECT section, record_json FROM furumusic__fed_podcast_relay + WHERE user_id = $1 AND section <> $2 + ORDER BY section, record_key", + ) + .bind(user_id) + .bind(SECTION_ALIASES) + .fetch_all(pool) + .await?; + for row in rows { + let section: String = row.get("section"); + let value: Value = row.get("record_json"); + fill_section(snapshot, §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..ea38851 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,6 +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(), + &crate::player::queue_items::LegacyColumns { + queue: original_queue.clone(), + current_track_id: state.current_track_id, + queue_position: state.queue_position, + }, + ); queue.retain(|track_id| !deleted.contains(track_id)); let current_track_id = state.current_track_id.filter(|id| !deleted.contains(id)); if queue == original_queue && current_track_id == state.current_track_id { @@ -763,16 +772,28 @@ async fn cleanup_playback_states( .clamp(0, i32::try_from(queue.len() - 1).unwrap_or(i32::MAX)) } }); + if let Some(typed) = &mut typed { + typed.retain_library( + |track_id| !deleted.contains(&track_id), + crate::player::queue_items::LegacyColumns { + queue: queue.clone(), + current_track_id, + queue_position, + }, + ); + } let position_ms = if current_track_id.is_some() { state.position_ms } else { 0 }; let queue_json = serde_json::to_string(&queue)?; + // The typed queue keeps its other items; a stale one is cleared. + let queue_items_json = typed.map(serde_json::to_value).transpose()?; sqlx::query( r#"UPDATE furumusic__playback_state SET current_track_id = $2, position_ms = $3, - queue_json = $4, queue_position = $5 + queue_json = $4, queue_position = $5, queue_items_json = $6 WHERE id = $1"#, ) .bind(state.id) @@ -780,6 +801,7 @@ async fn cleanup_playback_states( .bind(position_ms) .bind(queue_json) .bind(queue_position) + .bind(queue_items_json) .execute(&mut **transaction) .await?; } diff --git a/src/music/mod.rs b/src/music/mod.rs index 2ec4b03..8295f96 100644 --- a/src/music/mod.rs +++ b/src/music/mod.rs @@ -2838,6 +2838,110 @@ pub mod db_migrations { &[Operation::custom(add_import_playlist_destinations).build()]; } + // -- M0054: typed playback queue next to the legacy id list ------------ + + // (`m_0053` is taken by `src/user.rs` in the same app.) + + // `queue_json` keeps the library track ids and is still written, so an + // older release can run against the same database. The typed value adds + // the items that are not library tracks (podcast episodes, unresolved + // federated music, Jam placeholders) with their explicit source. + #[cot::db::migrations::migration_op] + async fn add_typed_playback_queue( + ctx: migrations::MigrationContext<'_>, + ) -> cot::db::Result<()> { + ctx.db + .raw( + "ALTER TABLE furumusic__playback_state + ADD COLUMN IF NOT EXISTS queue_items_json JSONB", + ) + .await?; + Ok(()) + } + + #[cot::db::migrations::migration_op] + async fn drop_typed_playback_queue( + ctx: migrations::MigrationContext<'_>, + ) -> cot::db::Result<()> { + ctx.db + .raw("ALTER TABLE furumusic__playback_state DROP COLUMN IF EXISTS queue_items_json") + .await?; + Ok(()) + } + + #[derive(Debug, Copy, Clone)] + pub struct M0054AddTypedPlaybackQueue; + impl migrations::Migration for M0054AddTypedPlaybackQueue { + const APP_NAME: &'static str = "furumusic"; + const MIGRATION_NAME: &'static str = "m_0054_add_typed_playback_queue"; + const DEPENDENCIES: &'static [migrations::MigrationDependency] = + &[migrations::MigrationDependency::migration( + "furumusic", + "m_0052_add_import_playlist_destinations", + )]; + const OPERATIONS: &'static [Operation] = &[Operation::custom(add_typed_playback_queue) + .backwards(drop_typed_playback_queue) + .build()]; + } + + // -- M0055: opaque podcast sync relay state (device-sync protocol v4) --- + + // Podcast registers received from trusted devices, kept as the shared + // contract JSON so this server can return them in its snapshots. This is + // not the podcast store: the web player has no podcast features yet. + #[cot::db::migrations::migration_op] + async fn create_fed_podcast_relay( + ctx: migrations::MigrationContext<'_>, + ) -> cot::db::Result<()> { + ctx.db + .raw( + "CREATE TABLE IF NOT EXISTS furumusic__fed_podcast_relay ( + user_id BIGINT NOT NULL, + section VARCHAR(16) NOT NULL, + record_key TEXT NOT NULL, + record_json JSONB NOT NULL, + updated_at_ms BIGINT NOT NULL, + PRIMARY KEY (user_id, section, record_key) + )", + ) + .await?; + Ok(()) + } + + /// Removes the operations a 0.12.x release cannot parse: the podcast + /// kinds relayed since device-sync protocol 4. Ends with its `WHERE` + /// clause, so tests can narrow it to one user. + pub(crate) const DELETE_PODCAST_SYNC_OPS_SQL: &str = + "DELETE FROM furumusic__fed_sync_ops WHERE kind LIKE 'podcast\\_%'"; + + // Release 0.12.x parses every unacknowledged operation it sends to a + // peer and fails the whole batch on an unknown kind, so the podcast + // operations relayed by 0.13 must go before it runs again (see + // docs/administration.md, "Rolling back to 0.12"). + #[cot::db::migrations::migration_op] + async fn drop_fed_podcast_relay(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> { + ctx.db.raw(DELETE_PODCAST_SYNC_OPS_SQL).await?; + ctx.db + .raw("DROP TABLE IF EXISTS furumusic__fed_podcast_relay") + .await?; + Ok(()) + } + + #[derive(Debug, Copy, Clone)] + pub struct M0055CreateFedPodcastRelay; + impl migrations::Migration for M0055CreateFedPodcastRelay { + const APP_NAME: &'static str = "furumusic"; + const MIGRATION_NAME: &'static str = "m_0055_create_fed_podcast_relay"; + const DEPENDENCIES: &'static [migrations::MigrationDependency] = + &[migrations::MigrationDependency::migration( + "furumusic", + "m_0054_add_typed_playback_queue", + )]; + const OPERATIONS: &'static [Operation] = &[Operation::custom(create_fed_podcast_relay) + .backwards(drop_fed_podcast_relay) + .build()]; + } + pub const MIGRATIONS: &[&SyncDynMigration] = &[ &M0006CreateMediaFile, &M0007CreateArtist, @@ -2881,5 +2985,7 @@ pub mod db_migrations { &M0050CreateMetadataFixHistory, &M0051AddListenStatisticsIndexes, &M0052AddImportPlaylistDestinations, + &M0054AddTypedPlaybackQueue, + &M0055CreateFedPodcastRelay, ]; } diff --git a/src/player/dto.rs b/src/player/dto.rs index 3c68d40..5e54bab 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)] @@ -263,6 +274,10 @@ pub(super) struct PlayerDevicePlaybackStateDto { pub(super) volume: f64, #[serde(default)] pub(super) updated_at_ms: i64, + /// The browser does not know the position of its current item, a podcast + /// episode it cannot play (`queue_items::POSITION_UNKNOWN_KEY`). + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + pub(super) position_unknown: bool, } #[derive(Debug, Serialize, JsonSchema)] diff --git a/src/player/mod.rs b/src/player/mod.rs index ac6e0bd..e4dbe71 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,15 @@ impl PlayerDeviceHub { let target_id = self .jam_target_device_id_locked(&state, jam) .ok_or("jam playback device is offline")?; + if user_id != jam.host_user_id { + let host_tracks = state + .playback_state_by_user + .get(&jam.host_user_id) + .map(|playback| playback.tracks.clone()) + .unwrap_or_default(); + restore_jam_command_payload(command, &mut payload, &host_tracks)?; + stamp_jam_participant_command(&mut payload); + } (jam.host_user_id, target_id) } else { let target_id = match target_device_id { @@ -1042,11 +1052,17 @@ impl PlayerDeviceHub { }) }) .unwrap_or(user_id); - state + let playback = state .playback_state_by_user .get(&playback_user_id) .cloned() - .map(|playback_state| playback_state_at(playback_state, now)) + .map(|playback_state| playback_state_at(playback_state, now)); + if playback_user_id == user_id { + return playback; + } + // Jam participants are outside the host's trusted devices: private + // items (podcast episodes) become opaque placeholders. + playback.map(redact_playback_state_for_jam) } fn jam_dtos_locked( @@ -1457,6 +1473,7 @@ mod device_tests { repeat_mode: "off".to_string(), volume: 0.7, updated_at_ms: current_millis(), + position_unknown: false, }, ); } @@ -1646,6 +1663,246 @@ pub struct PlayerPageTemplate { pub youtube_downloads_enabled: bool, } +#[cfg(test)] +mod queue_persistence_tests { + use super::*; + use music_dht::device_sync::PlaybackTrack; + + fn offline_pool() -> sqlx::PgPool { + sqlx::postgres::PgPoolOptions::new() + .connect_lazy("postgres://offline@127.0.0.1:1/offline") + .unwrap() + } + + fn request(queue_items: serde_json::Value, position: usize) -> PlaybackStateDto { + PlaybackStateDto { + current_track_id: Some(3), + position_ms: 1_000, + queue: vec![3, 4], + queue_position: 1, + shuffle: false, + repeat_mode: "off".into(), + volume: 0.5, + queue_items: Some(queue_items), + queue_items_position: Some(position), + } + } + + #[tokio::test] + async fn podcast_items_survive_persistence_and_reload() { + let episode = PlaybackTrack::podcast_episode(queue_items::test_episode()); + let browser_track = queue_items::external_track_json(&episode, 1, None); + // The browser sends `_queueItemsPayload(queue.tracks)`. + let dto = request( + serde_json::json!([ + {"kind": "library", "track_id": 3}, + {"kind": "external", "track": browser_track["wire_track"]}, + {"kind": "library", "track_id": 4}, + ]), + 1, + ); + let stored = stored_queue_from_request(&dto).unwrap(); + // Written to queue_items_json and read back with the legacy ids. + let column = serde_json::to_value(&stored).unwrap(); + let row = queue_items::LegacyColumns { + queue: dto.queue.clone(), + current_track_id: dto.current_track_id, + queue_position: dto.queue_position, + }; + let loaded = queue_items::StoredQueue::from_columns(Some(&column), &row).unwrap(); + assert_eq!(loaded, stored); + assert_eq!(loaded.position, 1); + let items = browser_queue_items(&offline_pool(), &loaded).await.unwrap(); + assert_eq!( + items[0], + serde_json::json!({"kind": "library", "track_id": 3}) + ); + assert_eq!(items[1]["kind"], "external"); + assert_eq!(items[1]["track"]["source"]["kind"], "podcast_episode"); + assert_eq!( + queue_items::wire_track_from_browser_json(&items[1]["track"]), + Some(episode) + ); + } + + #[test] + fn malformed_typed_queues_keep_the_legacy_ids_only() { + let dto = request( + serde_json::json!([{"kind": "external", "track": {"id": "x"}}]), + 0, + ); + assert!(stored_queue_from_request(&dto).is_none()); + let legacy_only = PlaybackStateDto { + queue_items: None, + ..request(serde_json::json!([]), 0) + }; + assert!(stored_queue_from_request(&legacy_only).is_none()); + // Older clients do not send the new fields. + let old: PlaybackStateDto = serde_json::from_value(serde_json::json!({ + "current_track_id": 3, "position_ms": 0, "queue": [3], "queue_position": 0, + "shuffle": false, "repeat_mode": "off", "volume": 0.7, + })) + .unwrap(); + assert!(old.queue_items.is_none()); + assert!(!serde_json::to_string(&old).unwrap().contains("queue_items")); + } +} + +#[cfg(test)] +mod jam_command_tests { + use super::*; + use music_dht::device_sync::{PRIVATE_ITEM_TITLE, PlaybackTrack}; + + fn library(id: i64) -> serde_json::Value { + serde_json::json!({"id": id, "title": format!("Song {id}"), "duration_seconds": 100.0}) + } + + fn host_tracks() -> Vec { + let episode = PlaybackTrack::podcast_episode(queue_items::test_episode()); + vec![ + library(1), + queue_items::external_track_json(&episode, 1, None), + library(2), + ] + } + + fn check(command: &str, payload: serde_json::Value) -> Result<(), &'static str> { + let mut payload = payload; + restore_jam_command_payload(command, &mut payload, &host_tracks()) + } + + #[test] + fn participants_cannot_remove_or_clear_private_items() { + assert!(check("queue_remove", serde_json::json!({"index": 1})).is_err()); + assert!(check("queue_clear", serde_json::json!({})).is_err()); + // Music can still be removed, and private items moved. + assert!(check("queue_remove", serde_json::json!({"index": 0})).is_ok()); + assert!(check("queue_remove", serde_json::json!({"index": 2})).is_ok()); + assert!( + check( + "queue_move", + serde_json::json!({"from_index": 1, "to_index": 0}) + ) + .is_ok() + ); + // The host runs `Number(index)`: other spellings of an index are refused. + for index in [ + serde_json::json!("1"), + serde_json::json!(1.0), + serde_json::json!(-1), + ] { + assert!(check("queue_remove", serde_json::json!({"index": index})).is_err()); + } + assert!(check("queue_remove", serde_json::json!({})).is_err()); + // Without private items the host queue can be cleared as before. + let mut payload = serde_json::json!({}); + assert!(restore_jam_command_payload("queue_clear", &mut payload, &[library(1)]).is_ok()); + } + + #[test] + fn participant_commands_reach_the_host_stamped() { + let hub = PlayerDeviceHub::default(); + hub.heartbeat(1, "host", None, None, None); + let jam = hub + .create_jam(1, "Host", "host", vec![(2, "Guest".to_string())]) + .unwrap(); + let jam_id = jam.jams[0].id.clone(); + hub.heartbeat(2, "guest", None, None, None); + hub.join_jam(2, "Guest", "guest", &jam_id).unwrap(); + let tracks = host_tracks(); + hub.heartbeat( + 1, + "host", + None, + Some(&jam_id), + Some(PlayerDevicePlaybackStateDto { + track: Some(tracks[0].clone()), + tracks, + index: 0, + position_seconds: 0.0, + duration_seconds: 100.0, + paused: false, + shuffle: false, + repeat_mode: "off".into(), + volume: 0.5, + updated_at_ms: 0, + position_unknown: false, + }), + ); + // Move the episode to the end, then remove index 2: the cached host + // state still has music there, so only the host can refuse it. + for (command, payload) in [ + ( + "queue_move", + serde_json::json!({"from_index": 1, "to_index": 2}), + ), + ("queue_remove", serde_json::json!({"index": 2})), + ("pause", serde_json::Value::Null), + ] { + hub.enqueue_command(2, None, Some(&jam_id), command, payload) + .unwrap(); + } + hub.enqueue_command( + 1, + None, + Some(&jam_id), + "queue_remove", + serde_json::json!({"index": 0}), + ) + .unwrap(); + let commands = hub.poll(1, "host", None, Some(&jam_id), None).commands; + let stamped: Vec = commands + .iter() + .map(|command| command.payload[JAM_PARTICIPANT_KEY] == true) + .collect(); + assert_eq!(stamped, [true, true, true, false]); + assert_eq!(commands[1].payload["index"], 2); + } + + #[test] + fn redacted_current_episode_has_no_duration() { + let tracks = host_tracks(); + let playback = PlayerDevicePlaybackStateDto { + track: Some(tracks[1].clone()), + tracks: tracks.clone(), + index: 1, + position_seconds: 1200.0, + duration_seconds: 1800.0, + paused: false, + shuffle: false, + repeat_mode: "off".into(), + volume: 0.5, + updated_at_ms: 0, + position_unknown: false, + }; + let redacted = redact_playback_state_for_jam(playback.clone()); + assert_eq!(redacted.duration_seconds, 0.0); + assert_eq!( + redacted.track.as_ref().unwrap()["title"], + PRIVATE_ITEM_TITLE + ); + assert_eq!(redacted.position_seconds, 1200.0); + let leaked = serde_json::to_string(&redacted).unwrap(); + assert!(!leaked.contains("1800") && !leaked.contains("Episode")); + + // A music track keeps its duration. + let music = redact_playback_state_for_jam(PlayerDevicePlaybackStateDto { + track: Some(tracks[0].clone()), + index: 0, + duration_seconds: 100.0, + ..playback.clone() + }); + assert_eq!(music.duration_seconds, 100.0); + + // Without `track` the current item is taken from `tracks[index]`. + let untracked = redact_playback_state_for_jam(PlayerDevicePlaybackStateDto { + track: None, + ..playback + }); + assert_eq!(untracked.duration_seconds, 0.0); + } +} + #[cfg(test)] mod page_template_tests { use super::*; @@ -5755,6 +6012,16 @@ async fn devices_select_handler( .and_then(normalize_device_id) .unwrap_or_else(|| target_device_id.clone()); let previous_active_id = hub.active_device_id_for_commands(user.id); + // Refuse a handoff the target cannot receive before ownership moves. + if let Some(fed_device_id) = fed_device_id_from_virtual(&target_device_id) + && previous_active_id.as_deref() != Some(target_device_id.as_str()) + && let Some(state) = hub.playback_state_json_for_commands(user.id) + && let Err(err) = crate::federation::handle() + .fed_device_web_transfer_check(user.id, fed_device_id, state) + .await + { + return Ok(json_error(StatusCode::CONFLICT, &format!("{err}"))); + } let Some(response) = hub.select(user.id, ¤t_device_id, &target_device_id) else { return Ok(json_error( @@ -5992,6 +6259,158 @@ async fn fed_devices_sync_handler( } } +/// Host playback state as shown to Jam participants +/// (`music_dht::device_sync::redact_for_jam` over the browser queue). +fn redact_playback_state_for_jam( + mut playback: PlayerDevicePlaybackStateDto, +) -> PlayerDevicePlaybackStateDto { + let index = usize::try_from(playback.index).unwrap_or(0); + let current_is_private = playback + .track + .as_ref() + .or_else(|| playback.tracks.get(index)) + .is_some_and(queue_items::browser_track_requires_podcast_support); + playback.tracks = queue_items::redact_tracks_for_jam(&playback.tracks); + if current_is_private { + // Placeholders carry no duration; the host's position is kept like + // `redact_for_jam` keeps `position_secs`. + playback.duration_seconds = 0.0; + } + if playback + .track + .as_ref() + .is_some_and(queue_items::browser_track_requires_podcast_support) + { + playback.track = playback.tracks.get(index).cloned().or_else(|| { + Some( + queue_items::redact_tracks_for_jam(std::slice::from_ref(playback.track.as_ref()?)) + [0] + .clone(), + ) + }); + } + playback +} + +/// Applies the Jam privacy rules to a participant command. +/// +/// Participants cannot add podcast episodes. A full queue they send (play or +/// transfer) gets the host's private items back in place of the +/// placeholders; queues that drop, duplicate or inject private items are +/// rejected. Participants cannot remove a private item, nor clear a queue +/// that holds one; they may still move it (`queue_move`). +fn restore_jam_command_payload( + command: &str, + payload: &mut serde_json::Value, + host_tracks: &[serde_json::Value], +) -> Result<(), &'static str> { + const REJECTED: &str = "podcast episodes are private and cannot be changed in a jam"; + let tracks: Vec = payload + .get("tracks") + .and_then(serde_json::Value::as_array) + .cloned() + .unwrap_or_default(); + let current = payload + .get("track") + .filter(|track| !track.is_null()) + .cloned(); + match command { + "queue_add_end" | "queue_add_next" => { + if tracks + .iter() + .any(queue_items::browser_track_requires_podcast_support) + { + return Err(REJECTED); + } + } + "play_track" | "play_from_index" | "transfer_state" => { + if !queue_items::jam_tracks_allowed(&tracks) + || current.as_ref().is_some_and(|track| { + !queue_items::jam_tracks_allowed(std::slice::from_ref(track)) + }) + { + return Err(REJECTED); + } + if tracks.is_empty() { + if current + .as_ref() + .is_some_and(queue_items::browser_track_requires_podcast_support) + { + return Err(REJECTED); + } + return Ok(()); + } + let restored = queue_items::restore_jam_tracks(host_tracks, &tracks).ok_or(REJECTED)?; + if let Some(object) = payload.as_object_mut() { + if current + .as_ref() + .is_some_and(queue_items::browser_track_requires_podcast_support) + { + let index = object + .get("index") + .and_then(serde_json::Value::as_u64) + .unwrap_or(0) as usize; + let track = restored.get(index).cloned().ok_or(REJECTED)?; + object.insert("track".to_string(), track); + } + object.insert("tracks".to_string(), serde_json::Value::Array(restored)); + } + } + "queue_remove" => { + // The participant view has the host's length and order, so the + // index names the same item on the host. + let index = payload + .get("index") + .and_then(serde_json::Value::as_u64) + .and_then(|index| usize::try_from(index).ok()); + let removes_private = match index { + Some(index) => host_tracks + .get(index) + .is_some_and(queue_items::browser_track_requires_podcast_support), + // The host browser runs `Number(index)`, so "1" or 1.0 would + // still name an item: only plain indexes pass a private queue. + None => host_tracks + .iter() + .any(queue_items::browser_track_requires_podcast_support), + }; + if removes_private { + return Err(REJECTED); + } + } + "queue_clear" + if host_tracks + .iter() + .any(queue_items::browser_track_requires_podcast_support) => + { + return Err(REJECTED); + } + _ => {} + } + Ok(()) +} + +/// Marks a Jam participant command for the host browser. +/// +/// `restore_jam_command_payload` checks the command against the host state of +/// the host's last report. The host browser runs its pending commands in one +/// batch, so an earlier command (a move, an insert) can make a checked index +/// name a private item there. The host browser applies the same rules to its +/// own queue for stamped commands (`_jamParticipantCommandAllowed`). +fn stamp_jam_participant_command(payload: &mut serde_json::Value) { + if !payload.is_object() { + *payload = serde_json::json!({}); + } + if let Some(object) = payload.as_object_mut() { + object.insert( + JAM_PARTICIPANT_KEY.to_string(), + serde_json::Value::Bool(true), + ); + } +} + +/// Command payload key set by the server on Jam participant commands. +const JAM_PARTICIPANT_KEY: &str = "jam_participant"; + fn stamp_jam_queue_tracks(payload: &mut serde_json::Value, user_id: i64, user_name: &str) { let Some(tracks) = payload .get_mut("tracks") @@ -6320,7 +6739,7 @@ async fn get_state_handler( }; let state = sqlx::query_as::<_, PlaybackStateRow>( - r#"SELECT current_track_id, position_ms, queue_json, queue_position, shuffle, repeat_mode::text as repeat_mode, volume + r#"SELECT current_track_id, position_ms, queue_json, queue_items_json, queue_position, shuffle, repeat_mode::text as repeat_mode, volume FROM furumusic__playback_state WHERE user_id = $1"#, ) .bind(user.id) @@ -6331,6 +6750,26 @@ async fn get_state_handler( let dto = match state { Some(s) => { let queue: Vec = serde_json::from_str(&s.queue_json).unwrap_or_default(); + // Prefer the typed queue while it matches the legacy columns. + let typed = queue_items::StoredQueue::from_columns( + s.queue_items_json.as_ref(), + &queue_items::LegacyColumns { + queue: queue.clone(), + current_track_id: s.current_track_id, + queue_position: s.queue_position, + }, + ); + let (queue_items, queue_items_position) = match typed { + Some(stored) => ( + Some( + browser_queue_items(pool, &stored) + .await + .map_err(|e| cot::Error::internal(e.to_string()))?, + ), + Some(stored.position), + ), + None => (None, None), + }; PlaybackStateDto { current_track_id: s.current_track_id, position_ms: s.position_ms, @@ -6339,6 +6778,8 @@ async fn get_state_handler( shuffle: s.shuffle, repeat_mode: s.repeat_mode, volume: s.volume, + queue_items, + queue_items_position, } } None => PlaybackStateDto { @@ -6349,12 +6790,51 @@ async fn get_state_handler( shuffle: false, repeat_mode: "off".to_string(), volume: 0.7, + queue_items: None, + queue_items_position: None, }, }; Json(dto).into_response() } +/// Typed queue items for the browser: library ids to load, external items +/// as browser track JSON with their verbatim wire item. +async fn browser_queue_items( + pool: &sqlx::PgPool, + stored: &queue_items::StoredQueue, +) -> anyhow::Result { + 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), + queue_items::LegacyColumns { + queue: dto.queue.clone(), + current_track_id: dto.current_track_id, + queue_position: dto.queue_position, + }, + ) +} + // --------------------------------------------------------------------------- // PUT /api/player/state // --------------------------------------------------------------------------- @@ -6372,15 +6852,21 @@ async fn put_state_handler( let queue_json = serde_json::to_string(&dto.queue).map_err(|e| cot::Error::internal(e.to_string()))?; + // `queue_json` is still written so an older release keeps working. + let queue_items_json = stored_queue_from_request(&dto) + .map(serde_json::to_value) + .transpose() + .map_err(|e| cot::Error::internal(e.to_string()))?; let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string(); sqlx::query( - r#"INSERT INTO furumusic__playback_state (user_id, current_track_id, position_ms, queue_json, queue_position, shuffle, repeat_mode, volume, updated_at) - VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) + r#"INSERT INTO furumusic__playback_state (user_id, current_track_id, position_ms, queue_json, queue_position, shuffle, repeat_mode, volume, updated_at, queue_items_json) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) ON CONFLICT (user_id) DO UPDATE SET current_track_id = $2, position_ms = $3, queue_json = $4, - queue_position = $5, shuffle = $6, repeat_mode = $7, volume = $8, updated_at = $9"#, + queue_position = $5, shuffle = $6, repeat_mode = $7, volume = $8, updated_at = $9, + queue_items_json = $10"#, ) .bind(user.id) .bind(dto.current_track_id) @@ -6391,6 +6877,7 @@ async fn put_state_handler( .bind(&dto.repeat_mode) .bind(dto.volume) .bind(&now) + .bind(queue_items_json) .execute(pool) .await .map_err(|e| cot::Error::internal(e.to_string()))?; diff --git a/src/player/queue_items.rs b/src/player/queue_items.rs new file mode 100644 index 0000000..69a3d04 --- /dev/null +++ b/src/player/queue_items.rs @@ -0,0 +1,701 @@ +//! Lossless queue items shared by the browser player, device sync and the +//! persisted playback state. +//! +//! The browser queue holds plain track JSON objects. Library tracks of this +//! server keep their usual shape. Every other item received from a trusted +//! device (unresolved federated music, podcast episodes, Jam private +//! placeholders) becomes an *external* item: display fields for the queue UI +//! plus the verbatim device-sync DTO under [`WIRE_TRACK_KEY`] and its explicit +//! [`PlaybackSource`] under [`SOURCE_KEY`]. Converting back to the wire uses +//! the verbatim DTO, so such items survive browser -> server -> peers -> +//! server -> browser unchanged even though this web player cannot play them. +//! +//! Gating and Jam decisions are delegated to `music_dht::device_sync`; this +//! module only maps browser JSON onto the shared DTOs. + +use music_dht::device_sync::{ + PRIVATE_ITEM_TITLE, PlaybackCommand, PlaybackSource, PlaybackStateWire, PlaybackTrack, + jam_command_allowed, redact_for_jam, restore_jam_private_items, +}; +use serde::{Deserialize, Serialize}; +use serde_json::Value; + +/// Browser track key holding the verbatim [`PlaybackTrack`] of an external item. +pub(crate) const WIRE_TRACK_KEY: &str = "wire_track"; +/// Browser track key holding the explicit [`PlaybackSource`] of an external item. +pub(crate) const SOURCE_KEY: &str = "source"; +/// Browser playback state key: `true` when the browser does not know the +/// position of its current item. That happens when it selects a podcast +/// episode it cannot play (Next, auto-advance, a click or a play command): +/// it is never told where the episode was left, and inventing 0 would +/// restart the episode for every device. The server then takes the +/// position from the episode's progress register. +pub(crate) const POSITION_UNKNOWN_KEY: &str = "position_unknown"; + +/// Reason shown for federated music that is not in this library. +pub(crate) const FED_UNAVAILABLE_REASON: &str = "Not available on this web player yet"; +/// Reason shown for podcast episodes, which this web player cannot play yet. +pub(crate) const PODCAST_UNAVAILABLE_REASON: &str = + "Podcast episodes cannot be played on the web player yet"; +/// Reason shown for Jam placeholders of someone else's private item. +pub(crate) const PRIVATE_UNAVAILABLE_REASON: &str = "Private item of the Jam host"; + +/// Version of the typed queue stored in `furumusic__playback_state.queue_items_json`. +pub(crate) const STORED_QUEUE_VERSION: u16 = 1; +/// Upper bound of persisted queue items; larger queues keep only `queue_json`. +pub(crate) const MAX_STORED_QUEUE_ITEMS: usize = 10_000; + +/// Browser JSON for a queue item that is not a library track of this server. +/// +/// `content_id` is the normalized content id of a music item, when known. +/// The `id` is a negative placeholder that is stable for the item and its +/// queue position, so the browser can tell items apart; it never refers to a +/// library track. +pub(crate) fn external_track_json( + track: &PlaybackTrack, + index: usize, + content_id: Option<&str>, +) -> Value { + let mut json = match &track.source { + Some(PlaybackSource::PodcastEpisode(episode)) => serde_json::json!({ + "id": placeholder_track_id(Some(episode.episode_id.as_str()), index), + "title": episode.episode_title, + "track_number": serde_json::Value::Null, + "disc_number": serde_json::Value::Null, + "duration_seconds": episode.duration_ms.unwrap_or(0).max(0) as f64 / 1_000.0, + "artists": artist_names_to_json(std::slice::from_ref(&episode.podcast_title)), + "featured_artists": [], + "release_id": 0, + "release_title": episode.podcast_title, + "release_year": serde_json::Value::Null, + "cover_url": serde_json::Value::Null, + "stream_url": "", + "uploader_name": "Podcast", + "audio_format": episode.mime, + "content_id": serde_json::Value::Null, + "unavailable": true, + "unavailable_reason": PODCAST_UNAVAILABLE_REASON, + }), + Some(PlaybackSource::Private) => serde_json::json!({ + "id": placeholder_track_id(Some("private"), index), + "title": PRIVATE_ITEM_TITLE, + "track_number": serde_json::Value::Null, + "disc_number": serde_json::Value::Null, + "duration_seconds": 0.0, + "artists": [], + "featured_artists": [], + "release_id": 0, + "release_title": "", + "release_year": serde_json::Value::Null, + "cover_url": serde_json::Value::Null, + "stream_url": "", + "uploader_name": "", + "content_id": serde_json::Value::Null, + "unavailable": true, + "unavailable_reason": PRIVATE_UNAVAILABLE_REASON, + }), + Some(PlaybackSource::Music) | None => music_placeholder_json(track, index, content_id), + }; + if let Some(object) = json.as_object_mut() { + if let Some(source) = &track.source + && let Ok(source) = serde_json::to_value(source) + { + object.insert(SOURCE_KEY.to_string(), source); + } + if let Ok(wire) = serde_json::to_value(track) { + object.insert(WIRE_TRACK_KEY.to_string(), wire); + } + } + json +} + +/// Display fields of unresolved federated music (unchanged from earlier +/// releases, which had no verbatim wire item). +fn music_placeholder_json(track: &PlaybackTrack, index: usize, content_id: Option<&str>) -> Value { + let artists = if !track.artist_names.is_empty() { + track.artist_names.clone() + } else if let Some(fed) = &track.fed { + fed.artist_names.clone() + } else { + Vec::new() + }; + let featured = if !track.featured_artist_names.is_empty() { + track.featured_artist_names.clone() + } else if let Some(fed) = &track.fed { + fed.featured_artist_names.clone() + } else { + Vec::new() + }; + let title = track + .fed + .as_ref() + .map(|fed| fed.title.as_str()) + .filter(|title| !title.trim().is_empty()) + .unwrap_or(&track.title); + let release_title = track + .fed + .as_ref() + .and_then(|fed| fed.release_title.as_deref()) + .filter(|title| !title.trim().is_empty()) + .unwrap_or(&track.release_title); + let content_id = content_id + .map(ToString::to_string) + .or_else(|| track.content_id.clone()) + .or_else(|| track.fed.as_ref().map(|fed| fed.content_id.clone())); + serde_json::json!({ + "id": placeholder_track_id(content_id.as_deref(), index), + "title": title, + "track_number": track.track_number, + "disc_number": track.disc_number, + "duration_seconds": track.duration_seconds, + "artists": artist_names_to_json(&artists), + "featured_artists": artist_names_to_json(&featured), + "release_id": 0, + "release_title": release_title, + "release_year": track.release_year, + "cover_url": serde_json::Value::Null, + "stream_url": "", + "uploader_name": "Federation", + "audio_format": track.audio_format.clone(), + "audio_bitrate": track.audio_bitrate, + "audio_sample_rate": track.audio_sample_rate, + "audio_bit_depth": track.audio_bit_depth, + "file_size_bytes": track.file_size_bytes, + "content_id": content_id, + "unavailable": true, + "unavailable_reason": FED_UNAVAILABLE_REASON, + }) +} + +fn artist_names_to_json(names: &[String]) -> Vec { + 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`, `legacy_current_track_id` and +/// `legacy_queue_position` record the legacy columns written alongside this +/// value: when they no longer match the row (an older release or a +/// legacy-only writer changed the queue or moved to another track since), +/// readers ignore the typed value and fall back to the legacy columns. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +pub(crate) struct StoredQueue { + /// Shape version, [`STORED_QUEUE_VERSION`]. + pub(crate) version: u16, + /// Index of the current item in `items`. + #[serde(default)] + pub(crate) position: usize, + /// Queue items in order. + #[serde(default)] + pub(crate) items: Vec, + /// `queue_json` ids written together with this value. + #[serde(default)] + pub(crate) legacy_queue: Vec, + /// `current_track_id` written together with this value. + #[serde(default)] + pub(crate) legacy_current_track_id: Option, + /// `queue_position` written together with this value (`None`: unknown, + /// the value is not used). + #[serde(default)] + pub(crate) legacy_queue_position: Option, +} + +/// Legacy queue columns of a `furumusic__playback_state` row. +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub(crate) struct LegacyColumns { + /// `queue_json`: library track ids. + pub(crate) queue: Vec, + /// `current_track_id`. + pub(crate) current_track_id: Option, + /// `queue_position`. + pub(crate) queue_position: i32, +} + +/// One persisted queue item. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[serde(tag = "kind", rename_all = "snake_case")] +pub(crate) enum StoredQueueItem { + /// Library track of this server. + Library { + /// Local track id. + track_id: i64, + }, + /// Any other item, kept verbatim with its explicit `source`. + External { + /// Device-sync queue item. + track: Box, + }, +} + +impl StoredQueue { + /// Builds the persisted value; `None` when the queue exceeds the bound. + /// + /// Jam private placeholders are dropped: they stand for the Jam host's + /// items, never for items of this user's own queue. + pub(crate) fn new( + items: Vec, + position: usize, + legacy: LegacyColumns, + ) -> Option { + if items.len() > MAX_STORED_QUEUE_ITEMS { + return None; + } + let mut stored = Self { + version: STORED_QUEUE_VERSION, + position, + items, + legacy_queue: Vec::new(), + legacy_current_track_id: None, + legacy_queue_position: None, + }; + stored.retain_items(|item| match item { + StoredQueueItem::Library { .. } => true, + StoredQueueItem::External { track } => !track.is_private_placeholder(), + }); + stored.set_legacy(legacy); + Some(stored) + } + + /// Reads the typed column, preferring it over the legacy columns only + /// when it has a known version and was written together with exactly + /// these legacy values. + pub(crate) fn from_columns(typed: Option<&Value>, legacy: &LegacyColumns) -> Option { + let stored = serde_json::from_value::(typed?.clone()).ok()?; + (stored.version == STORED_QUEUE_VERSION + && stored.legacy_queue == legacy.queue + && stored.legacy_current_track_id == legacy.current_track_id + && stored.legacy_queue_position == Some(legacy.queue_position) + && stored.items.len() <= MAX_STORED_QUEUE_ITEMS) + .then_some(stored) + } + + /// Removes library tracks rejected by `keep` and records the new legacy + /// columns. The current position follows its item, or the item after it + /// when the current item was removed. + pub(crate) fn retain_library(&mut self, keep: impl Fn(i64) -> bool, legacy: LegacyColumns) { + self.retain_items(|item| match item { + StoredQueueItem::Library { track_id } => keep(*track_id), + StoredQueueItem::External { .. } => true, + }); + self.set_legacy(legacy); + } + + fn retain_items(&mut self, keep: impl Fn(&StoredQueueItem) -> bool) { + let original_position = self.position; + let mut position = self.position; + let mut index = 0; + self.items.retain(|item| { + let retained = keep(item); + if !retained && index < original_position { + position = position.saturating_sub(1); + } + index += 1; + retained + }); + self.position = position.min(self.items.len().saturating_sub(1)); + } + + fn set_legacy(&mut self, legacy: LegacyColumns) { + self.legacy_queue = legacy.queue; + self.legacy_current_track_id = legacy.current_track_id; + self.legacy_queue_position = Some(legacy.queue_position); + } +} + +/// A valid podcast episode reference for tests. +#[cfg(test)] +pub(crate) fn test_episode() -> music_dht::podcast::PodcastEpisodeRef { + use music_dht::podcast::{EpisodeId, FeedUrl, PodcastEpisodeRef, PodcastId}; + let feed_url = FeedUrl::parse("https://podcasts.example/feed.xml?token=Ab").unwrap(); + let podcast_id = PodcastId::from_feed_url(&feed_url); + let episode_id = EpisodeId::from_guid(&podcast_id, "episode-42").unwrap(); + PodcastEpisodeRef { + podcast_id, + episode_id, + feed_url, + podcast_title: "Example Cast".into(), + episode_title: "Episode 42".into(), + audio_url: "https://cdn.example/ep42.mp3".into(), + mime: Some("audio/mpeg".into()), + duration_ms: Some(1_800_000), + published_at_ms: Some(1_700_000_000_000), + season: Some(2), + episode_number: Some(42), + image_url: None, + progress_generation: Some(7), + } +} + +#[cfg(test)] +mod tests { + use super::*; + use music_dht::podcast::EpisodeId; + + fn episode() -> music_dht::podcast::PodcastEpisodeRef { + test_episode() + } + + fn library(id: i64) -> Value { + serde_json::json!({"id": id, "title": format!("Track {id}"), "stream_url": format!("/api/player/stream/{id}")}) + } + + #[test] + fn podcast_item_round_trips_through_browser_json() { + let mut wire = PlaybackTrack::podcast_episode(episode()); + wire.play_count = 3; + let json = external_track_json(&wire, 4, None); + assert_eq!(json["unavailable"], true); + assert_eq!(json["unavailable_reason"], PODCAST_UNAVAILABLE_REASON); + assert_eq!(json["title"], "Episode 42"); + assert_eq!(json[SOURCE_KEY]["kind"], "podcast_episode"); + assert!(json["id"].as_i64().unwrap() < 0); + // The browser stores and echoes the object; the item is unchanged. + let echoed: Value = serde_json::from_str(&json.to_string()).unwrap(); + assert_eq!(wire_track_from_browser_json(&echoed), Some(wire)); + } + + #[test] + fn private_and_unresolved_music_keep_their_wire_item() { + let private = PlaybackTrack::private_placeholder(); + let json = external_track_json(&private, 0, None); + assert_eq!(json["title"], PRIVATE_ITEM_TITLE); + assert_eq!(json[SOURCE_KEY]["kind"], "private"); + assert_eq!(wire_track_from_browser_json(&json), Some(private)); + + let mut music = PlaybackTrack::private_placeholder(); + music.source = None; + music.title = "Remote song".into(); + music.content_id = Some(format!("b3:{}", "a".repeat(64))); + let json = external_track_json(&music, 1, music.content_id.as_deref()); + assert!(json.get(SOURCE_KEY).is_none()); + assert_eq!(json["unavailable_reason"], FED_UNAVAILABLE_REASON); + assert_eq!(wire_track_from_browser_json(&json), Some(music)); + } + + #[test] + fn library_tracks_are_not_external() { + assert_eq!(wire_track_from_browser_json(&library(5)), None); + let mut music_source = library(6); + music_source[SOURCE_KEY] = serde_json::json!({"kind": "music"}); + assert_eq!(wire_track_from_browser_json(&music_source), None); + } + + #[test] + fn source_only_items_use_shared_constructors() { + let json = serde_json::json!({ + "id": -1, + SOURCE_KEY: serde_json::to_value(PlaybackSource::PodcastEpisode(Box::new(episode()))).unwrap(), + }); + assert_eq!( + wire_track_from_browser_json(&json), + Some(PlaybackTrack::podcast_episode(episode())) + ); + // A malformed verbatim item falls back to the explicit source. + let mut tampered = json.clone(); + tampered[WIRE_TRACK_KEY] = serde_json::json!({"id": "x"}); + assert_eq!( + wire_track_from_browser_json(&tampered), + Some(PlaybackTrack::podcast_episode(episode())) + ); + } + + #[test] + fn jam_redaction_hides_episodes_and_restores_them_in_order() { + let first = external_track_json(&PlaybackTrack::podcast_episode(episode()), 1, None); + let mut other = episode(); + other.episode_title = "Episode 43".into(); + other.episode_id = EpisodeId::from_guid(&other.podcast_id, "episode-43").unwrap(); + let second = external_track_json(&PlaybackTrack::podcast_episode(other), 3, None); + let host = vec![library(1), first.clone(), library(2), second.clone()]; + + let redacted = redact_tracks_for_jam(&host); + assert_eq!(redacted[0], host[0]); + assert_eq!(redacted[1]["title"], PRIVATE_ITEM_TITLE); + let leaked = serde_json::to_string(&redacted).unwrap(); + assert!(!leaked.contains("Episode 4") && !leaked.contains("podcasts.example")); + assert!(!leaked.contains("cdn.example") && !leaked.contains("Example Cast")); + + // The participant reorders music and moves a placeholder. + let participant = vec![ + redacted[3].clone(), + library(2), + redacted[1].clone(), + library(1), + ]; + let restored = restore_jam_tracks(&host, &participant).unwrap(); + assert_eq!( + restored, + vec![first.clone(), library(2), second, library(1)] + ); + + // Dropping, duplicating or injecting private items is rejected. + assert!(restore_jam_tracks(&host, &[library(1), redacted[1].clone()]).is_none()); + assert!(restore_jam_tracks(&host, &[first.clone(), redacted[1].clone()]).is_none()); + assert!(!jam_tracks_allowed(std::slice::from_ref(&first))); + assert!(jam_tracks_allowed(&[library(9)])); + } + + fn legacy(queue: &[i64], current_track_id: Option, queue_position: i32) -> LegacyColumns { + LegacyColumns { + queue: queue.to_vec(), + current_track_id, + queue_position, + } + } + + #[test] + fn stored_queue_prefers_typed_value_only_while_legacy_ids_match() { + let items = vec![ + StoredQueueItem::Library { track_id: 3 }, + StoredQueueItem::External { + track: Box::new(PlaybackTrack::podcast_episode(episode())), + }, + StoredQueueItem::Library { track_id: 4 }, + ]; + // The episode is current: the browser wrote its placeholder id. + let written = legacy(&[3, -11, 4], Some(-11), 1); + let stored = StoredQueue::new(items, 1, written.clone()).unwrap(); + let value = serde_json::to_value(&stored).unwrap(); + assert_eq!(value["version"], 1); + assert_eq!(value["items"][1]["kind"], "external"); + assert_eq!( + value["items"][1]["track"]["source"]["kind"], + "podcast_episode" + ); + assert_eq!( + StoredQueue::from_columns(Some(&value), &written), + Some(stored.clone()) + ); + // A rollback release rewrote queue_json: fall back to it. + assert_eq!( + StoredQueue::from_columns(Some(&value), &legacy(&[3, 4], Some(4), 1)), + None + ); + // A rollback release kept the ids but moved to another track (Next + // or a click): the typed position is stale, fall back as well. + assert_eq!( + StoredQueue::from_columns(Some(&value), &legacy(&[3, -11, 4], Some(4), 2)), + None + ); + assert_eq!( + StoredQueue::from_columns(Some(&value), &legacy(&[3, -11, 4], Some(-11), 0)), + None + ); + // Values without the recorded current item are not trusted. + let mut unknown = value.clone(); + unknown + .as_object_mut() + .unwrap() + .remove("legacy_queue_position"); + assert_eq!(StoredQueue::from_columns(Some(&unknown), &written), None); + let mut future = value.clone(); + future["version"] = serde_json::json!(2); + assert_eq!(StoredQueue::from_columns(Some(&future), &written), None); + assert_eq!(StoredQueue::from_columns(None, &written), None); + } + + #[test] + fn stored_queue_never_keeps_jam_placeholders() { + let items = vec![ + StoredQueueItem::Library { track_id: 3 }, + StoredQueueItem::External { + track: Box::new(PlaybackTrack::private_placeholder()), + }, + StoredQueueItem::External { + track: Box::new(PlaybackTrack::podcast_episode(episode())), + }, + StoredQueueItem::Library { track_id: 4 }, + ]; + let stored = StoredQueue::new(items.clone(), 3, legacy(&[3, 4], Some(4), 1)).unwrap(); + assert_eq!( + stored.items, + vec![items[0].clone(), items[2].clone(), items[3].clone()] + ); + assert_eq!(stored.position, 2); + // A current placeholder hands the position to the next item. + let stored = StoredQueue::new(items.clone(), 1, legacy(&[3, 4], None, 0)).unwrap(); + assert_eq!(stored.position, 1); + assert_eq!(stored.items[1], items[2]); + } + + #[test] + fn stored_queue_cleanup_keeps_external_items_and_position() { + let items = vec![ + StoredQueueItem::Library { track_id: 3 }, + StoredQueueItem::External { + track: Box::new(PlaybackTrack::podcast_episode(episode())), + }, + StoredQueueItem::Library { track_id: 4 }, + ]; + let mut stored = StoredQueue::new(items.clone(), 1, legacy(&[3, 4], None, 0)).unwrap(); + stored.retain_library(|id| id != 3, legacy(&[4], None, 0)); + assert_eq!(stored.items, items[1..].to_vec()); + assert_eq!(stored.position, 0); + assert_eq!(stored.legacy_queue, vec![4]); + // The cleanup's new legacy columns are what readers compare with. + let value = serde_json::to_value(&stored).unwrap(); + assert_eq!( + StoredQueue::from_columns(Some(&value), &legacy(&[4], None, 0)), + Some(stored) + ); + + let mut current_removed = + StoredQueue::new(items.clone(), 2, legacy(&[3, 4], Some(4), 1)).unwrap(); + current_removed.retain_library(|id| id != 4, legacy(&[3], None, 0)); + assert_eq!(current_removed.position, 1); + assert!( + StoredQueue::new( + vec![items[0].clone(); MAX_STORED_QUEUE_ITEMS + 1], + 0, + LegacyColumns::default() + ) + .is_none() + ); + } +} 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..83890f7 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 }}", @@ -755,6 +757,9 @@ document.addEventListener('alpine:init', () => { _listenedSeconds: 0, _lastAudioTime: 0, _localSourceTrackId: null, + // The current item is one this player cannot play and nobody told it + // that item's position (see _showUnplayableQueueItem). + _positionUnknown: false, _remoteExecuting: false, _remoteStateBaseTime: 0, _remoteStateReceivedAt: 0, @@ -772,6 +777,9 @@ document.addEventListener('alpine:init', () => { }); audio.addEventListener('timeupdate', () => { + // Unloading the audio for an unplayable item fires a late + // timeupdate at 0; keep that item's handed-off position. + if (!this._currentItemHasLocalAudio()) return; this.currentTime = audio.currentTime; this.duration = audio.duration || 0; this.progress = this.duration > 0 ? (this.currentTime / this.duration) * 100 : 0; @@ -857,6 +865,7 @@ document.addEventListener('alpine:init', () => { playQueueIndex(idx) { const queue = Alpine.store('queue'); if (!queue || idx < 0 || idx >= queue.tracks.length) return; + const previousIndex = queue.currentIndex; queue.currentIndex = idx; const track = queue.tracks[idx]; if (track?.federation_pending && track?._federationTrack) { @@ -880,6 +889,24 @@ document.addEventListener('alpine:init', () => { })); return; } + if (this._isUnplayableQueueItem(track)) { + // Podcast episodes stay in the queue; this player skips them. + const step = idx >= previousIndex ? 1 : -1; + let playable = this._playableQueueIndex(queue.tracks, idx, step); + if (playable < 0 && (this.repeatMode === 'all' || this.shuffle)) { + // Wrap around like the queue itself does. + playable = this._playableQueueIndex(queue.tracks, step > 0 ? 0 : queue.tracks.length - 1, step); + } + if (playable < 0) { + // Staying on the current item keeps its position; any + // other item's position is unknown here, never 0. + this._showUnplayableQueueItem(track, track === this.currentTrack ? this._knownPosition() : null); + return; + } + queue.currentIndex = playable; + this._playLocal(queue.tracks[playable]); + return; + } this._playLocal(track); }, @@ -900,7 +927,13 @@ document.addEventListener('alpine:init', () => { }, _playLocal(track, options = {}) { + if (this._isUnplayableQueueItem(track)) { + this._recordHistory('replaced'); + this._showUnplayableQueueItem(track, options.position_seconds); + return; + } this._recordHistory('replaced'); + this._positionUnknown = false; this.currentTrack = track; this._historyTrack = track; this._prefetchedQueueKey = null; @@ -957,9 +990,31 @@ document.addEventListener('alpine:init', () => { this._sendRemote('resume'); return; } + if (this._isUnplayableQueueItem(this.currentTrack)) { + // Not next(): with repeat "one" it would resume this item again. + this._skipUnplayableCurrentItem(); + return; + } audio.play().catch(() => {}); }, + _skipUnplayableCurrentItem() { + const queue = Alpine.store('queue'); + const tracks = queue?.tracks || []; + let idx = this._playableQueueIndex(tracks, Number(queue?.currentIndex ?? -1) + 1, 1); + if (idx < 0 && this.repeatMode === 'all') idx = this._playableQueueIndex(tracks, 0, 1); + if (idx < 0) { + this._showUnplayableQueueItem(this.currentTrack, this._knownPosition()); + return; + } + this.playQueueIndex(idx); + }, + + _knownPosition() { + // The current item's position, or null when this player was never told it. + return this._positionUnknown ? null : this.currentTime; + }, + toggle() { if (!this.currentTrack) return; if (this.isPlaying) { this.pause(); } @@ -980,6 +1035,11 @@ document.addEventListener('alpine:init', () => { this._sendRemote('seek', { time: nextTime }); return; } + if (this._isUnplayableQueueItem(this.currentTrack)) { + // Nothing is loaded in