Compare commits

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

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

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

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

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

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

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

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

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

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

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

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

No files matched your search

+27
View File
@@ -1,5 +1,32 @@
# Changelog
## v0.13.0 — 2026-11-19
- Use the shared `music-dht` 0.6 device-sync types and announce device-sync
protocol 4. Podcast operations and snapshot sections from other devices are
kept and relayed; devices below protocol 4 never receive them.
- Keep podcast episodes and other non-library queue items through the web
player, with their explicit source. The player labels and skips them; the
typed queue is stored next to `queue_json` (migrations `m_0054`, `m_0055`).
A handoff through the web player keeps the position of the current episode.
- Refuse a playback transfer of a queue with podcast episodes to a device that
needs an update, and ignore its playback commands while the queue has them.
- Store the protocol version each device reports itself instead of this
server's version; invites carry the inviter's version.
- An episode that the web player selects without knowing its position (Next,
auto-advance, a click) resumes from its synchronized progress on the next
device instead of restarting at 0. Repeat all and shuffle continue past
episodes; Prev and seeking work on them.
- Jam guests see podcast episodes of the host as private items, without their
duration, and cannot add, remove or clear them; the host browser enforces
this on its own queue. Guests do not keep the placeholders after the Jam.
- Metadata Repair can still undo deletions recorded before the typed queue
column was added.
- Rolling back to 0.12 requires removing the relayed podcast operations first;
see "Rolling back to 0.12" in `docs/administration.md`. After a rollback, the
typed queue is used again only if 0.12 left the queue and its current track
unchanged.
## v0.10.6 — 2026-09-02
- Recover federation automatically after sleep, prolonged idle, or a degraded rendezvous transport.
Generated
+39 -60
View File
@@ -453,12 +453,6 @@ version = "0.22.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
[[package]]
name = "base64"
version = "0.23.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
[[package]]
name = "base64ct"
version = "1.8.3"
@@ -811,9 +805,9 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
[[package]]
name = "combine"
version = "4.6.9"
version = "4.6.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4356eba6976435498d05a311ee9fc486da3bc81c200d3f0d7dd9703b41913f92"
checksum = "cfc320937d09e6de266b31b9afb480f197d7a861be86be7cb2ea7e5d1bfffc5e"
dependencies = [
"bytes",
"memchr",
@@ -1849,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",
@@ -1994,7 +1987,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
[[package]]
name = "furumusic"
version = "0.12.5"
version = "0.13.0"
dependencies = [
"anyhow",
"async-stream",
@@ -2167,9 +2160,9 @@ dependencies = [
[[package]]
name = "generator"
version = "0.8.11"
version = "0.8.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1be81b31c9ce4caf7f3178eeb90662bb1864d3ad363ec6bdada3201adff19c37"
checksum = "b3b854b0e584ead1a33f18b2fcad7cf7be18b3875c78816b753639aa501513ae"
dependencies = [
"cc",
"cfg-if",
@@ -3357,9 +3350,9 @@ dependencies = [
[[package]]
name = "js-sys"
version = "0.3.106"
version = "0.3.104"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"
checksum = "0e0c1080212aad755ea003d18543e8768dd432c48819efd73a7bf1e39b7a5a3a"
dependencies = [
"cfg-if",
"futures-util",
@@ -3409,9 +3402,9 @@ checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
[[package]]
name = "libredox"
version = "0.1.25"
version = "0.1.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "61ff90caf6077a803a240f62fdbe88645a890bbca49ef8174c3cb0404362171d"
checksum = "8d8f1ea3f21fd3405dcaf6c9b5c1630af9afc422d9073ea39c5f6d6c772e08ed"
dependencies = [
"bitflags 2.13.1",
"libc",
@@ -3907,17 +3900,14 @@ dependencies = [
[[package]]
name = "music-dht"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ce81f361952228654c28a46e41555f2c3d1520bf8c6c76562e7a53f70dd38e1"
source = "git+https://gt.hexor.cy/Sanapach/frid.git?branch=podcasts%2Fcontract#65d6ca2f14a1324dc129b90694da83ceb55c60dc"
dependencies = [
"async-trait",
"blake3",
"data-encoding",
"encoding_rs",
"federation-net",
"futures",
"postcard",
"quick-xml 0.41.0",
"rand 0.9.5",
"rusqlite",
"serde",
@@ -3926,7 +3916,6 @@ dependencies = [
"tokio",
"tracing",
"unicode-normalization",
"url",
]
[[package]]
@@ -4049,9 +4038,9 @@ dependencies = [
[[package]]
name = "netdev"
version = "0.46.3"
version = "0.46.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3c52c2584961c68f5a6e3356797344061f818c93b8acc9cd6d7e284795e563e"
checksum = "4db4135b187ddae3b6813c4f9d9ac9d5181859fa6a08b4e006c63a130974ed62"
dependencies = [
"block2",
"dispatch2",
@@ -4167,7 +4156,7 @@ dependencies = [
"n0-future",
"n0-watcher",
"netdev 0.45.0",
"netdev 0.46.3",
"netdev 0.46.2",
"netlink-packet-core 0.8.2",
"netlink-packet-route 0.31.0",
"netlink-proto",
@@ -4465,9 +4454,9 @@ dependencies = [
[[package]]
name = "objc2"
version = "0.6.5"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "08849bbd4767dfae9457696856ae1c84fe4e0281bbe4a7abff2d0e06fb7981f8"
checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
dependencies = [
"objc2-encode",
]
@@ -4642,9 +4631,9 @@ dependencies = [
[[package]]
name = "openssl-probe"
version = "0.2.2"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7e036b411754132fd6b74e94b74e9a13c5cf606fa93d1885c35860d3060820b1"
checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
[[package]]
name = "openssl-sys"
@@ -4936,13 +4925,13 @@ checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
[[package]]
name = "plist"
version = "1.10.3"
version = "1.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "327a4cb2ad49dc48adfdc9da89e22c64d488b508c67a044d71ba729e4521a285"
checksum = "7da1d65da6dd5d1e44199ac0f58712d241c0f439f80adea8924d832384087f85"
dependencies = [
"base64 0.23.1",
"base64 0.22.1",
"indexmap 2.14.1",
"quick-xml 0.42.0",
"quick-xml 0.41.0",
"serde",
"time",
]
@@ -5184,15 +5173,6 @@ dependencies = [
"memchr",
]
[[package]]
name = "quick-xml"
version = "0.42.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b"
dependencies = [
"memchr",
]
[[package]]
name = "quinn"
version = "0.11.11"
@@ -5687,9 +5667,9 @@ dependencies = [
[[package]]
name = "rustix"
version = "1.1.5"
version = "1.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "891efababe418670775f199f0d233d84843c227a0949a883ce15b37c78d6629d"
checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
dependencies = [
"bitflags 2.13.1",
"errno",
@@ -7781,9 +7761,9 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
[[package]]
name = "wasm-bindgen"
version = "0.2.129"
version = "0.2.127"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"
checksum = "1b70935747edd64d89de3efa29d73789b806c15798f8e7dca4d8ac356b50ce70"
dependencies = [
"cfg-if",
"once_cell",
@@ -7794,20 +7774,19 @@ dependencies = [
[[package]]
name = "wasm-bindgen-futures"
version = "0.4.79"
version = "0.4.77"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3cbab34de2d982e9b48e18d216d04c4a6f641066ff19ffb699980f591ee3610e"
checksum = "6b7777d5cc23d0e91404e53ce2d5e8ec7acae3026b16233dba62cd3246457950"
dependencies = [
"js-sys",
"tokio",
"wasm-bindgen",
]
[[package]]
name = "wasm-bindgen-macro"
version = "0.2.129"
version = "0.2.127"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"
checksum = "77775f8f3f7217702089053b94958f8f54061a3f663417df76e19cbdcca29bc1"
dependencies = [
"quote",
"wasm-bindgen-macro-support",
@@ -7815,22 +7794,22 @@ dependencies = [
[[package]]
name = "wasm-bindgen-macro-support"
version = "0.2.129"
version = "0.2.127"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"
checksum = "e11d33f857dc2fb11b8bc75aee111aa9cbeb12cd9f25efd3d4c2a3dd4e235284"
dependencies = [
"bumpalo",
"proc-macro2",
"quote",
"syn 3.0.4",
"syn 2.0.119",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
version = "0.2.129"
version = "0.2.127"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"
checksum = "7ef64dbcc55df09c7e5a46182d181c2cfa3e925f3da937ea764728b4bbb9dcbf"
dependencies = [
"unicode-ident",
]
@@ -7863,9 +7842,9 @@ dependencies = [
[[package]]
name = "web-sys"
version = "0.3.106"
version = "0.3.104"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "88261b9deccee56594c11a3460c462c41f58d148598fe70ad77070126a68aba4"
checksum = "c435338968042f4f59a557f690a253676d47ce13ceb55d70100e7facf6620a30"
dependencies = [
"js-sys",
"wasm-bindgen",
@@ -7883,9 +7862,9 @@ dependencies = [
[[package]]
name = "webpki-root-certs"
version = "1.0.11"
version = "1.0.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e49d0e65abc00c142e8f9428da991da9f1a250c39be97459901eb12b9b49f62a"
checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b"
dependencies = [
"rustls-pki-types",
]
+6 -2
View File
@@ -1,6 +1,6 @@
[package]
name = "furumusic"
version = "0.12.5"
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 = { version = "0.6.0", features = ["podcast-feed"] }
music-dht = "0.6.0"
[patch.crates-io]
# Unpublished frid (MR-F1); remove once music-dht 0.6.0 is on crates.io.
music-dht = { git = "https://gt.hexor.cy/Sanapach/frid.git", branch = "podcasts/contract" }
+25 -44
View File
@@ -2,50 +2,6 @@
[Project overview](../README.md) · [Installation](setup.md) · [Development and tests](development.md)
## Podcasts
The player's **Podcasts** entry below **My uploads** manages RSS/Atom subscriptions.
Subscriptions start private. Publishing shares a feed card with other instance users
and, while federation is enabled, the Frid podcast discovery overlay. Network search
uses the same overlay as Furumi TUI; subscribing fetches the origin feed itself rather
than trusting a publisher's claimed redirect or episode metadata. Feed URLs that may
contain private access tokens require an additional confirmation before publication.
The catalogue and downloaded audio are shared by the instance. Unsubscribing removes
only that user's subscription and publication; other subscribers keep their access.
Listening position and played status are personal. Playback can begin from the source
while a separate download saves the episode on the server. Cached episodes play from
the server even when the publisher is unavailable; a connection to this server is
still required.
The internal **podcast_refresh** job checks subscribed feeds every 30 minutes and
downloads missing episodes, retrying failed downloads on later runs. Its schedule can
be changed in the normal job settings. A manual check makes new episode metadata
available before the audio download finishes. Up to three downloads run concurrently;
each episode is limited to 2 GiB. Podcast sources must resolve to public HTTP(S)
addresses, including after redirects.
**Settings → Podcasts → Manage podcasts** lists every known podcast, subscriber and
publication counts, and saved episode counts. Administrators can check a feed, remove
its publications, clear saved audio, or delete the podcast for every user. Audio
retention is disabled by default. When enabled, its day count is measured from the
download time; the periodic job removes old audio while keeping episode descriptions
and listening progress. Removed audio is downloaded again only on an explicit save
or playback request.
Connected devices use Frid device-sync v4 to exchange podcast subscriptions, share
decisions, listening progress and listening-session records. Adding or removing a
subscription on one connected device updates the others; unsubscribe and share-off
registers survive offline devices reconnecting. Older v3 clients keep music sync and
receive no unsupported podcast operations or snapshot sections.
The main player search also finds accessible podcasts by words in their titles,
descriptions and authors. All query words must match; a private subscription is visible
only to its owner. Podcast search and the admin artist/release/track search use the
explicit ICU `und` collation `furumusic_unicode`, so case matching does not depend on
the database's initial locale (including databases created with the `C` locale).
PostgreSQL must include ICU support to apply migration `m_0055_podcast_sync_unicode_search`.
## Access and public sharing
OIDC identifies accounts by issuer and subject. Matching admin groups take
@@ -115,6 +71,31 @@ Trusted-device pairing is separate from public catalog discovery. It connects
a user's own Furumi players so likes, playlists, playback state, and control can
move between approved devices.
Queues synchronized from other Furumi players can contain podcast episodes. The
web player keeps them in the queue, in order and with their position, and shows
them as **Podcast · not playable in the web player yet**; local playback skips
them. A device that does not support podcasts yet (device-sync protocol below
4, for example an older terminal player) cannot receive such a queue: selecting
it as the playback device shows that it needs an update, and the episodes stay
in the queue. Jam guests see podcast episodes of the host only as private items.
### Rolling back to 0.12
Release 0.13 relays podcast synchronization operations from other Furumi
players. Release 0.12 cannot read them: device synchronization would fail for
every device that has not received them yet. Before you start a 0.12 release
on a database that 0.13 used, stop the server and remove those operations:
```sql
DELETE FROM furumusic__fed_sync_ops WHERE kind LIKE 'podcast\_%';
```
Devices that support podcasts keep their own podcast state. The relay table
`furumusic__fed_podcast_relay` and the typed queue column can stay: 0.12
ignores them, and after the next upgrade 0.13 returns the relayed podcast state
in its snapshots again and uses the typed queue only while it matches the
queue, current track and position that 0.12 saved.
## Admin statistics
The only admin interface is `/admin/v2`, also reachable from `/admin/`.
+45 -26
View File
@@ -35,6 +35,51 @@ source code, templates or prompts reuse the dependency layer when its recipe and
toolchain are unchanged. Both dependency and application builds use `--locked`.
Update the pinned build tools in `Dockerfile`; changing them rebuilds the cache.
## Connected devices and podcast queue items
Trusted-device sync uses the shared `music_dht::device_sync` types (no local
copies) and announces protocol version 4. The web player has no podcast
features yet, but it keeps every v4 element it receives:
- podcast operations stay in the operation log and are relayed to v4 devices
only; their registers and the podcast snapshot sections are merged with the
shared `music_dht::podcast` rules into `furumusic__fed_podcast_relay`
(opaque contract JSON) and returned in this server's snapshots;
- queue items that are not library tracks become external browser items
(`source` plus the verbatim `wire_track`), so podcast episodes and Jam
placeholders survive peer → server → browser → server → peer unchanged;
- `furumusic__playback_state.queue_items_json` stores the typed queue next to
`queue_json`. `queue_json` (library ids) is still written for rollback; the
typed value is used only while the legacy columns it recorded
(`queue_json`, `current_track_id`, `queue_position`) match the row. Jam
placeholders are never stored in a user's own queue.
- a browser that selects a podcast episode it cannot play does not know the
episode's position. It reports `position_unknown`, and the server sends the
resume position of the relayed progress register instead of 0. Jam
participant commands carry `jam_participant`; the host browser checks them
against its own queue.
Rolling back to 0.12 needs the podcast operations removed from the operation
log first; see "Rolling back to 0.12" in `administration.md`.
Everything sent to a device is gated by the version that device reported itself
(`profile_protocol_version`; relayed profiles only raise it). See the podcast
contract (`PODCASTS.md`) and `PLAYBACK_PROTOCOL.md` in the Frid repository.
```bash
cargo test devices:: queue_items podcast_relay queue_persistence
node --test tests/player_queue_sources.test.cjs
# Migrated disposable PostgreSQL (start the server against it once):
FURU_DEVICE_SYNC_TEST_DATABASE_URL=postgresql://... \
cargo test devices::postgres_tests -- --ignored
FURU_METADATA_FIX_TEST_DATABASE_URL=postgresql://... \
cargo test undo_accepts_playback_archives_written_before_the_typed_queue -- --ignored
```
`wire_compat_tests` compares the shared types with the private copies of
0.12.x byte for byte; `fixtures/v3_hello.golden.json` is the v3 shape. Rewrite
it only for a deliberate change, with `FURUMUSIC_BLESS_GOLDEN=1`.
## Contributing
Bug reports, design discussions, and patches are welcome. Before submitting a
@@ -55,32 +100,6 @@ FURUMUSIC_LASTFM_TEST_DATABASE_URL=postgres://user:pass@localhost/test_db \
## Access and sharing tests
Podcast regressions include browser-store tests in `tests/podcasts.test.cjs` and an
isolated PostgreSQL fixture for multiuser subscriptions, progress generations,
retention and administrator actions:
```bash
node --test tests/podcasts.test.cjs
FURU_PODCAST_RENDER_FIXTURE=1 cargo test renders_podcast_navigation_and_views
node tests/browser-podcast-ui.cjs
FURU_PODCAST_TEST_DATABASE_URL=postgresql://... cargo test podcasts -- --include-ignored
FURU_PODCAST_TEST_DATABASE_URL=postgresql://... cargo test admin_unicode_search -- --include-ignored
```
Use a disposable database. The PostgreSQL test creates and drops a unique schema;
its audio files use a unique temporary directory. Normal podcast tests need no network.
The podcast fixture includes real Frid v4 subscription operations, snapshot exchange,
offline unsubscribe replay, legacy-peer filtering, and private Unicode search. The
admin fixture exercises list counts, all three catalogue lists and the track picker
with Cyrillic and Greek searches. Use a PostgreSQL build with ICU support; running
these fixtures on a database created with locale `C` covers the locale regression.
The browser UI fixture checks direct list/detail hashes on first load and reload,
back navigation, RSS artwork and broken-image fallbacks, explicit subscriptions,
compact search cards and mobile layout. It uses isolated API fixtures with the
rendered application. Set `PLAYWRIGHT_MODULE` and `CHROME_PATH` as for the other
browser tests. Optional `ALPINE_FIXTURE` points to a local Alpine.js bundle for
offline browser runs; otherwise the page loads Alpine from its normal CDN.
The access regression suite uses a disposable migrated database and a local OIDC
provider with signed tokens and PKCE:
+75 -6
View File
@@ -1438,18 +1438,28 @@ async fn delete_entities(
}
}
// Playback queues contain local IDs rather than foreign keys.
let states: Vec<(i64, Option<i64>, String)> = sqlx::query_as(
"SELECT id,current_track_id,queue_json FROM furumusic__playback_state FOR UPDATE",
// (id, current_track_id, queue_json, queue_items_json, queue_position)
type QueueRow = (i64, Option<i64>, String, Option<serde_json::Value>, i32);
let states: Vec<QueueRow> = sqlx::query_as(
"SELECT id,current_track_id,queue_json,queue_items_json,queue_position FROM furumusic__playback_state FOR UPDATE",
)
.fetch_all(&mut *conn)
.await?;
for (id, current, queue_json) in states {
for (id, current, queue_json, queue_items_json, queue_position) in states {
let mut queue: Vec<i64> = serde_json::from_str(&queue_json).unwrap_or_default();
if !current.is_some_and(|id| deleted.tracks.contains(&id))
&& !queue.iter().any(|id| deleted.tracks.contains(id))
{
continue;
}
let mut typed = crate::player::queue_items::StoredQueue::from_columns(
queue_items_json.as_ref(),
&crate::player::queue_items::LegacyColumns {
queue: queue.clone(),
current_track_id: current,
queue_position,
},
);
let before: String = sqlx::query_scalar(
"SELECT to_jsonb(t)::text FROM furumusic__playback_state t WHERE id=$1",
)
@@ -1461,8 +1471,19 @@ async fn delete_entities(
let position = current
.and_then(|id| queue.iter().position(|x| *x == id))
.unwrap_or(0) as i32;
let after: String = sqlx::query_scalar("UPDATE furumusic__playback_state SET current_track_id=$2,queue_json=$3,queue_position=$4,position_ms=CASE WHEN current_track_id IS DISTINCT FROM $2 THEN 0 ELSE position_ms END WHERE id=$1 RETURNING to_jsonb(furumusic__playback_state)::text")
.bind(id).bind(current).bind(serde_json::to_string(&queue)?).bind(position).fetch_one(&mut *conn).await?;
if let Some(typed) = &mut typed {
typed.retain_library(
|id| !deleted.tracks.contains(&id),
crate::player::queue_items::LegacyColumns {
queue: queue.clone(),
current_track_id: current,
queue_position: position,
},
);
}
let queue_items_json = typed.map(serde_json::to_value).transpose()?;
let after: String = sqlx::query_scalar("UPDATE furumusic__playback_state SET current_track_id=$2,queue_json=$3,queue_position=$4,queue_items_json=$5,position_ms=CASE WHEN current_track_id IS DISTINCT FROM $2 THEN 0 ELSE position_ms END WHERE id=$1 RETURNING to_jsonb(furumusic__playback_state)::text")
.bind(id).bind(current).bind(serde_json::to_string(&queue)?).bind(position).bind(queue_items_json).fetch_one(&mut *conn).await?;
archived.push(ArchivedRows {
table: "furumusic__playback_state".into(),
rows: serde_json::json!([serde_json::from_str::<serde_json::Value>(&before)?]),
@@ -1502,6 +1523,7 @@ async fn restore_deleted(conn: &mut PgConnection, archived: &[ArchivedRows]) ->
&[
"current_track_id",
"queue_json",
"queue_items_json",
"queue_position",
"position_ms",
]
@@ -1515,7 +1537,9 @@ async fn restore_deleted(conn: &mut PgConnection, archived: &[ArchivedRows]) ->
})
.collect::<Vec<_>>()
.join(",");
let affected = sqlx::query(&format!("UPDATE {table} t SET {assignments} FROM jsonb_array_elements($1::jsonb) WITH ORDINALITY b(value,n) JOIN jsonb_array_elements($2::jsonb) WITH ORDINALITY a(value,n) USING(n) WHERE to_jsonb(t)=a.value"))
// Archives written before m_0054 have no `queue_items_json` key;
// compare them without the column added since.
let affected = sqlx::query(&format!("UPDATE {table} t SET {assignments} FROM jsonb_array_elements($1::jsonb) WITH ORDINALITY b(value,n) JOIN jsonb_array_elements($2::jsonb) WITH ORDINALITY a(value,n) USING(n) WHERE (CASE WHEN a.value ? 'queue_items_json' THEN to_jsonb(t) ELSE to_jsonb(t) - 'queue_items_json' END)=a.value"))
.bind(entry.rows.to_string()).bind(after.to_string()).execute(&mut *conn).await?.rows_affected();
anyhow::ensure!(
affected as usize == after.as_array().map_or(0, Vec::len),
@@ -1804,6 +1828,51 @@ pub(super) async fn undo(
mod tests {
use super::*;
#[tokio::test]
#[ignore = "requires a migrated disposable database in FURU_METADATA_FIX_TEST_DATABASE_URL"]
async fn undo_accepts_playback_archives_written_before_the_typed_queue() {
let pool =
sqlx::PgPool::connect(&std::env::var("FURU_METADATA_FIX_TEST_DATABASE_URL").unwrap())
.await
.unwrap();
let mut tx = pool.begin().await.unwrap();
let user_id = 9_000_000_000 + i64::from(std::process::id());
// State after the deletion, read back like an archive written by 0.12
// (`to_jsonb` of the row before m_0054 added `queue_items_json`).
let after: serde_json::Value = sqlx::query_scalar(
"INSERT INTO furumusic__playback_state (user_id,current_track_id,position_ms,queue_json,queue_position,shuffle,repeat_mode,volume,updated_at) VALUES ($1,NULL,0,'[]',0,false,'off',0.7,'now') RETURNING to_jsonb(furumusic__playback_state) - 'queue_items_json'",
)
.bind(user_id)
.fetch_one(&mut *tx)
.await
.unwrap();
let mut before = after.clone();
before["queue_json"] = serde_json::json!("[123456789]");
before["position_ms"] = serde_json::json!(5000);
let archive = ArchivedRows {
table: "furumusic__playback_state".into(),
rows: serde_json::json!([before]),
after: Some(serde_json::json!([after])),
};
restore_deleted(&mut tx, std::slice::from_ref(&archive))
.await
.unwrap();
let (queue_json, position_ms, typed): (String, i32, Option<serde_json::Value>) =
sqlx::query_as(
"SELECT queue_json,position_ms,queue_items_json FROM furumusic__playback_state WHERE user_id=$1",
)
.bind(user_id)
.fetch_one(&mut *tx)
.await
.unwrap();
assert_eq!(queue_json, "[123456789]");
assert_eq!(position_ms, 5000);
assert_eq!(typed, None);
// A row changed since the deletion is still refused.
assert!(restore_deleted(&mut tx, &[archive]).await.is_err());
tx.rollback().await.unwrap();
}
fn snapshot() -> Snapshot {
Snapshot {
artists: vec![ArtistState {
+15 -105
View File
@@ -3978,11 +3978,11 @@ async fn search_tracks(
LEFT JOIN furumusic__release r ON r.id = t.release_id \
LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id AND ta.role = 'main' \
LEFT JOIN furumusic__artist a ON a.id = ta.artist_id \
WHERE t.title COLLATE furumusic_unicode ILIKE $1 OR COALESCE(r.title::text, '') COLLATE furumusic_unicode ILIKE $1 OR COALESCE(a.name::text, '') COLLATE furumusic_unicode ILIKE $1 \
WHERE t.title ILIKE $1 OR COALESCE(r.title::text, '') ILIKE $1 OR COALESCE(a.name::text, '') ILIKE $1 \
GROUP BY t.id, r.id, r.title \
ORDER BY CASE \
WHEN LOWER(t.title::text COLLATE furumusic_unicode) = LOWER($2::text COLLATE furumusic_unicode) THEN 0 \
WHEN t.title COLLATE furumusic_unicode ILIKE $3 THEN 1 \
WHEN LOWER(t.title::text) = LOWER($2) THEN 0 \
WHEN t.title ILIKE $3 THEN 1 \
ELSE 2 \
END, \
t.title_sort ASC, t.id ASC \
@@ -4306,9 +4306,9 @@ fn push_library_search_filter(
};
match kind {
"releases" => {
qb.push(" AND (r.title COLLATE furumusic_unicode ILIKE ");
qb.push(" AND (r.title ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR a.name COLLATE furumusic_unicode ILIKE ");
qb.push(" OR a.name ILIKE ");
qb.push_bind(pattern);
qb.push(")");
}
@@ -4322,16 +4322,16 @@ fn push_library_search_filter(
qb.push(")");
}
"tracks" => {
qb.push(" AND (t.title COLLATE furumusic_unicode ILIKE ");
qb.push(" AND (t.title ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR r.title COLLATE furumusic_unicode ILIKE ");
qb.push(" OR r.title ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR a.name COLLATE furumusic_unicode ILIKE ");
qb.push(" OR a.name ILIKE ");
qb.push_bind(pattern);
qb.push(")");
}
_ => {
qb.push(" AND a.name COLLATE furumusic_unicode ILIKE ");
qb.push(" AND a.name ILIKE ");
qb.push_bind(pattern);
}
}
@@ -4356,7 +4356,7 @@ async fn load_artist_items(
WHERE 1=1",
);
if let Some(pattern) = search_pattern {
qb.push(" AND a.name COLLATE furumusic_unicode ILIKE ");
qb.push(" AND a.name ILIKE ");
qb.push_bind(pattern);
}
qb.push(" GROUP BY a.id ORDER BY secondary_count DESC, a.name ASC LIMIT ");
@@ -4390,9 +4390,9 @@ async fn load_release_items(
WHERE 1=1",
);
if let Some(pattern) = search_pattern {
qb.push(" AND (r.title COLLATE furumusic_unicode ILIKE ");
qb.push(" AND (r.title ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR a.name COLLATE furumusic_unicode ILIKE ");
qb.push(" OR a.name ILIKE ");
qb.push_bind(pattern);
qb.push(")");
}
@@ -4428,11 +4428,11 @@ async fn load_track_items(
WHERE 1=1",
);
if let Some(pattern) = search_pattern {
qb.push(" AND (t.title COLLATE furumusic_unicode ILIKE ");
qb.push(" AND (t.title ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR r.title COLLATE furumusic_unicode ILIKE ");
qb.push(" OR r.title ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR a.name COLLATE furumusic_unicode ILIKE ");
qb.push(" OR a.name ILIKE ");
qb.push_bind(pattern);
qb.push(")");
}
@@ -4612,96 +4612,6 @@ fn clean_search(search: Option<&str>) -> Option<String> {
.map(|s| s.chars().take(120).collect())
}
#[cfg(test)]
mod unicode_search_tests {
use super::*;
#[tokio::test]
#[ignore = "requires FURU_PODCAST_TEST_DATABASE_URL pointing to a disposable PostgreSQL database"]
async fn admin_unicode_search_matches_counts_lists_and_track_picker() {
let url = std::env::var("FURU_PODCAST_TEST_DATABASE_URL").unwrap();
let admin = PgPool::connect(&url).await.unwrap();
let schema = format!("unicode_search_{}", uuid::Uuid::new_v4().simple());
sqlx::query(&format!("CREATE SCHEMA {schema}"))
.execute(&admin)
.await
.unwrap();
let search_path = format!("SET search_path TO {schema}");
let pool = sqlx::postgres::PgPoolOptions::new()
.max_connections(2)
.after_connect(move |conn, _| {
let statement = search_path.clone();
Box::pin(async move {
sqlx::query(&statement).execute(conn).await?;
Ok(())
})
})
.connect(&url)
.await
.unwrap();
sqlx::query(
"CREATE COLLATION furumusic_unicode(provider=icu,locale='und',deterministic=true)",
)
.execute(&pool)
.await
.unwrap();
for statement in include_str!("../../tests/unicode_search_fixture.sql")
.split(';')
.filter(|s| !s.trim().is_empty())
{
sqlx::query(statement).execute(&pool).await.unwrap();
}
for query in ["АЛИСА", "алиса", "АлИсА"] {
let pattern = Some(format!("%{query}%"));
for kind in ["artists", "releases", "tracks"] {
assert_eq!(
count_library(&pool, kind, pattern.clone()).await.unwrap(),
1,
"{kind}: {query}"
);
}
assert_eq!(
load_artist_items(&pool, pattern.clone(), 10, 0)
.await
.unwrap()
.len(),
1
);
assert_eq!(
load_release_items(&pool, pattern.clone(), 10, 0)
.await
.unwrap()
.len(),
1
);
assert_eq!(
load_track_items(&pool, pattern, 10, 0).await.unwrap().len(),
1
);
}
for query in ["солнце", "СОЛНЦЕ", "ελληνικά", "ΕΛΛΗΝΙΚΆ", "трек", "ТРЕК"]
{
assert_eq!(
load_track_items(&pool, Some(format!("%{query}%")), 10, 0)
.await
.unwrap()
.len(),
1,
"{query}"
);
assert_eq!(
search_tracks(&pool, query, 10).await.unwrap().len(),
1,
"picker: {query}"
);
}
pool.close().await;
sqlx::query(&format!("DROP SCHEMA {schema} CASCADE"))
.execute(&admin)
.await
.unwrap();
}
}
fn normalize_name(value: &str) -> String {
value.trim().to_lowercase()
}
+2 -4
View File
@@ -5,8 +5,8 @@ use std::time::Duration;
use anyhow::Result;
use music_dht::StreamAcceptor;
use music_dht::capabilities::{
CAPABILITIES_PROTOCOL_VERSION, CapabilityManifest, CapabilityMessage, DEVICE_SYNC_ID, JAM_ID,
SIMILARITY_ID, read_message, write_message,
CAPABILITIES_PROTOCOL_VERSION, CapabilityManifest, CapabilityMessage, JAM_ID, SIMILARITY_ID,
read_message, write_message,
};
use super::serve::AUDIO_PROTOCOL_VERSION;
@@ -15,8 +15,6 @@ fn local_manifest() -> CapabilityManifest {
CapabilityManifest::frid("furumusic", env!("CARGO_PKG_VERSION"))
// The web server does not expose federation Jam yet.
.without_protocol(JAM_ID)
// Keep the advertised version aligned with the web device-sync adapter.
.with_protocol(DEVICE_SYNC_ID, super::devices::PROTOCOL_VERSION)
.with_protocol("audio", AUDIO_PROTOCOL_VERSION)
.with_protocol(
SIMILARITY_ID,
+581 -589
View File
File diff suppressed because it is too large. Load diff
@@ -0,0 +1 @@
{"type":"hello","group_id":"grp_1","profile":{"device_id":"tui_a","name":"TUI","client_version":"0.3.4","protocol_version":3,"endpoint_id":"e","endpoint_ticket":"t","revoked":false,"revoke_cutoff_seq":null,"updated_at_ms":5},"devices":[{"device_id":"tui_a","name":"TUI","client_version":"0.3.4","protocol_version":3,"endpoint_id":"e","endpoint_ticket":"t","revoked":false,"revoke_cutoff_seq":null,"updated_at_ms":5},{"device_id":"web_b","name":"TUI","client_version":"0.3.4","protocol_version":3,"endpoint_id":"e","endpoint_ticket":"t","revoked":false,"revoke_cutoff_seq":null,"updated_at_ms":5}],"vector":{"tui_a":12,"web_b":4},"ops":[{"op_id":"tui_a:1","origin_device_id":"tui_a","seq":1,"hlc_ms":1700000000001,"payload":{"kind":"track_like_set","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","liked":true,"fed":{"item_id":"item","owner":"owner","title":"Song","artist_names":["A"],"featured_artist_names":[],"year":2001,"duration_seconds":180,"content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","release_title":"Album","track_number":1,"disc_number":1}}},{"op_id":"tui_a:2","origin_device_id":"tui_a","seq":2,"hlc_ms":1700000000002,"payload":{"kind":"playlist_created","playlist_id":"pl","title":"Mix"}},{"op_id":"tui_a:3","origin_device_id":"tui_a","seq":3,"hlc_ms":1700000000003,"payload":{"kind":"playlist_renamed","playlist_id":"pl","title":"Mix 2"}},{"op_id":"tui_a:4","origin_device_id":"tui_a","seq":4,"hlc_ms":1700000000004,"payload":{"kind":"playlist_track_added","playlist_id":"pl","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","position":0,"fed":null}},{"op_id":"tui_a:5","origin_device_id":"tui_a","seq":5,"hlc_ms":1700000000005,"payload":{"kind":"playlist_track_removed","playlist_id":"pl","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111"}},{"op_id":"tui_a:6","origin_device_id":"tui_a","seq":6,"hlc_ms":1700000000006,"payload":{"kind":"playlist_deleted","playlist_id":"pl"}},{"op_id":"tui_a:7","origin_device_id":"tui_a","seq":7,"hlc_ms":1700000000007,"payload":{"kind":"device_profile_set","name":"TUI","client_version":"0.3.4","endpoint_ticket":"t","endpoint_id":"e"}},{"op_id":"tui_a:8","origin_device_id":"tui_a","seq":8,"hlc_ms":1700000000008,"payload":{"kind":"device_trusted","target_device_id":"web_b"}},{"op_id":"tui_a:9","origin_device_id":"tui_a","seq":9,"hlc_ms":1700000000009,"payload":{"kind":"device_revoked","target_device_id":"old","target_max_seq_seen":3}},{"op_id":"tui_a:10","origin_device_id":"tui_a","seq":10,"hlc_ms":1700000000010,"payload":{"kind":"playback_command","target_device_id":"web_b","command":{"kind":"set_state","state":{"queue":[{"id":7,"title":"Song","track_number":1,"disc_number":null,"duration_seconds":180.5,"artist_names":["A"],"featured_artist_names":["B"],"release_id":3,"release_title":"Album","release_year":2001,"file_path":"","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","audio_format":"flac","audio_bitrate":900,"audio_sample_rate":44100,"audio_bit_depth":16,"file_size_bytes":12345,"play_count":2,"fed":{"item_id":"item","owner":"owner","title":"Song","artist_names":["A"],"featured_artist_names":[],"year":2001,"duration_seconds":180,"content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","release_title":"Album","track_number":1,"disc_number":1}},{"id":0,"title":"Remote","track_number":null,"disc_number":null,"duration_seconds":0.0,"artist_names":[],"featured_artist_names":[],"release_id":0,"release_title":"","release_year":null,"file_path":"","content_id":null,"audio_format":null,"audio_bitrate":null,"audio_sample_rate":null,"audio_bit_depth":null,"file_size_bytes":null,"play_count":0,"fed":null}],"queue_pos":1,"playing":true,"paused":false,"idle_since_ms":null,"position_secs":42.5,"volume":73,"shuffle":true,"repeat":"all"},"seek":true},"authority":{"version":1,"claim":{"counter":3,"issuer":"tui_a","owner":"tui_a"},"sequence":9}}},{"op_id":"tui_a:11","origin_device_id":"tui_a","seq":11,"hlc_ms":1700000000011,"payload":{"kind":"playback_command","target_device_id":"web_b","command":{"kind":"active_changed","active_device_id":"web_b","active_device_name":"WEB","state":{"queue":[{"id":7,"title":"Song","track_number":1,"disc_number":null,"duration_seconds":180.5,"artist_names":["A"],"featured_artist_names":["B"],"release_id":3,"release_title":"Album","release_year":2001,"file_path":"","content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","audio_format":"flac","audio_bitrate":900,"audio_sample_rate":44100,"audio_bit_depth":16,"file_size_bytes":12345,"play_count":2,"fed":{"item_id":"item","owner":"owner","title":"Song","artist_names":["A"],"featured_artist_names":[],"year":2001,"duration_seconds":180,"content_id":"b3:1111111111111111111111111111111111111111111111111111111111111111","release_title":"Album","track_number":1,"disc_number":1}},{"id":0,"title":"Remote","trackLine truncated
+575
View File
@@ -0,0 +1,575 @@
//! Version gating and lossless queue bridge (device-sync protocol v4).
use super::*;
use crate::player::queue_items::{self, test_episode};
use music_dht::podcast::{
EpisodeId, FeedUrl, ListenSession, PodcastId, PodcastMeta, ProgressStatus,
};
const CONTENT_ID: &str = "b3:2222222222222222222222222222222222222222222222222222222222222222";
fn podcast_id() -> PodcastId {
PodcastId::from_feed_url(&FeedUrl::parse("https://podcasts.example/feed.xml").unwrap())
}
fn episode_id() -> EpisodeId {
EpisodeId::from_guid(&podcast_id(), "ep-1").unwrap()
}
fn music_track(id: i64) -> PlaybackTrack {
let mut track = PlaybackTrack::private_placeholder();
track.source = None;
track.id = id;
track.title = format!("Song {id}");
track
}
fn state(queue: Vec<PlaybackTrack>) -> PlaybackStateWire {
PlaybackStateWire {
queue,
queue_pos: 0,
playing: true,
paused: false,
idle_since_ms: None,
position_secs: 12.5,
volume: 70,
shuffle: false,
repeat: PlaybackRepeat::Off,
playback_rate: None,
}
}
fn podcast_state() -> PlaybackStateWire {
state(vec![
music_track(1),
PlaybackTrack::podcast_episode(test_episode()),
])
}
/// One payload of every operation kind (music-only playback commands).
fn every_payload(playback: PlaybackStateWire) -> Vec<SyncOpPayload> {
let session = ListenSession {
session_id: "s1".into(),
episode_id: episode_id(),
podcast_id: podcast_id(),
device_id: "tui_a".into(),
started_at_ms: 1,
ended_at_ms: 2,
start_position_ms: 0,
end_position_ms: 1,
listened_ms: 1,
completed: false,
};
let meta: PodcastMeta = serde_json::from_value(serde_json::json!({
"feed_url": "https://podcasts.example/feed.xml", "title": "Cast"
}))
.unwrap();
vec![
SyncOpPayload::TrackLikeSet {
content_id: CONTENT_ID.into(),
liked: true,
fed: None,
},
SyncOpPayload::PlaylistCreated {
playlist_id: "p".into(),
title: "t".into(),
},
SyncOpPayload::PlaylistRenamed {
playlist_id: "p".into(),
title: "t".into(),
},
SyncOpPayload::PlaylistDeleted {
playlist_id: "p".into(),
},
SyncOpPayload::PlaylistTrackAdded {
playlist_id: "p".into(),
content_id: CONTENT_ID.into(),
position: 0,
fed: None,
},
SyncOpPayload::PlaylistTrackRemoved {
playlist_id: "p".into(),
content_id: CONTENT_ID.into(),
},
SyncOpPayload::DeviceProfileSet {
name: "n".into(),
client_version: "v".into(),
endpoint_ticket: "t".into(),
endpoint_id: "e".into(),
protocol_version: Some(4),
},
SyncOpPayload::DeviceTrusted {
target_device_id: "d".into(),
},
SyncOpPayload::DeviceRevoked {
target_device_id: "d".into(),
target_max_seq_seen: 1,
},
SyncOpPayload::PlaybackCommand {
target_device_id: "d".into(),
command: PlaybackCommand::SetState {
state: playback,
seek: false,
},
authority: None,
},
SyncOpPayload::ListenRecorded {
event: ListenEvent {
listen_id: "l".into(),
content_id: CONTENT_ID.into(),
started_at_ms: 1,
listened_ms: 1,
track_duration_ms: None,
ended_reason: ListenEndReason::Finished,
track: ListenTrackMetadata {
title: "t".into(),
artist_names: vec!["a".into()],
featured_artist_names: vec![],
release_title: None,
},
},
},
SyncOpPayload::PodcastSubscriptionSet {
podcast_id: podcast_id(),
subscribed: true,
podcast: meta,
feed_aliases: vec![],
generation: 1,
},
SyncOpPayload::PodcastShareSet {
podcast_id: podcast_id(),
shared: false,
generation: 1,
},
SyncOpPayload::PodcastFeedAliasesAdded {
podcast_id: podcast_id(),
feed_aliases: vec![FeedUrl::parse("https://podcasts.example/new.xml").unwrap()],
},
SyncOpPayload::PodcastProgressSet {
episode_id: episode_id(),
podcast_id: podcast_id(),
position_ms: 1,
status: ProgressStatus::InProgress,
generation: 1,
session_id: "s1".into(),
episode: None,
},
SyncOpPayload::PodcastListenRecorded {
session,
episode: None,
},
]
}
#[test]
fn stored_kind_is_the_wire_tag() {
for payload in every_payload(state(vec![])) {
let value = serde_json::to_value(&payload).unwrap();
assert_eq!(payload_kind(&payload), value["kind"].as_str().unwrap());
}
}
#[test]
fn op_gating_matrix_matches_the_shared_helper() {
// The SQL kind filter must hide exactly what `op_allowed_for_peer`
// rejects (playback commands are content-dependent and checked in Rust).
for version in 1..=PROTOCOL_VERSION {
let hidden = op_kinds_hidden_from(version);
for payload in every_payload(state(vec![music_track(1)])) {
let kind = payload_kind(&payload);
assert_eq!(
hidden.contains(&kind),
!op_allowed_for_peer(&payload, version),
"{kind} for v{version}"
);
}
}
assert!(
op_kinds_hidden_from(3)
.iter()
.all(|kind| kind.starts_with("podcast_"))
);
assert_eq!(op_kinds_hidden_from(3).len(), 5);
assert!(op_kinds_hidden_from(4).is_empty());
}
#[test]
fn playback_gating_matrix() {
let music = state(vec![music_track(1), music_track(2)]);
let podcasts = podcast_state();
let private = state(vec![PlaybackTrack::private_placeholder()]);
for version in 1..=PROTOCOL_VERSION {
let v4 = version >= 4;
// Snapshots and handoffs.
assert!(playback_allowed_for_peer(&music, version));
assert_eq!(playback_allowed_for_peer(&podcasts, version), v4);
assert_eq!(playback_allowed_for_peer(&private, version), v4);
// Commands from the peer.
assert!(playback_command_allowed_from_peer(&music, version));
assert_eq!(playback_command_allowed_from_peer(&podcasts, version), v4);
// Stamped playback command operations.
let command = |state: &PlaybackStateWire| SyncOpPayload::PlaybackCommand {
target_device_id: "d".into(),
command: PlaybackCommand::ActiveChanged {
active_device_id: "d".into(),
active_device_name: "D".into(),
state: state.clone(),
},
authority: None,
};
assert!(op_allowed_for_peer(&command(&music), version));
assert_eq!(op_allowed_for_peer(&command(&podcasts), version), v4);
}
}
#[test]
fn browser_state_gating_sees_podcast_items() {
let with_podcast = serde_json::json!({
"tracks": [
{"id": 5, "title": "Library song"},
queue_items::external_track_json(&PlaybackTrack::podcast_episode(test_episode()), 1, None),
],
"index": 0,
});
let shadow = browser_state_shadow(&with_podcast);
assert!(!playback_command_allowed_from_peer(&shadow, 3));
assert!(playback_command_allowed_from_peer(&shadow, 4));
let music_only = serde_json::json!({"tracks": [{"id": 5}], "index": 0});
assert!(playback_command_allowed_from_peer(
&browser_state_shadow(&music_only),
3
));
}
#[test]
fn relayed_versions_never_downgrade_and_self_reports_replace() {
let profile = |id: &str, version: u16| DeviceProfileWire {
device_id: id.into(),
name: "D".into(),
client_version: "x".into(),
protocol_version: version,
endpoint_id: String::new(),
endpoint_ticket: String::new(),
revoked: false,
revoke_cutoff_seq: None,
updated_at_ms: 0,
};
// A v3 relay lists every device with its own constant.
let relayed = VersionReport::for_listed(&profile("tui_b", 3), Some("tui_a"));
assert_eq!(relayed, VersionReport::Relayed(3));
assert_eq!(relayed.resolve(Some(4)), 4);
assert_eq!(relayed.resolve(None), 3);
assert_eq!(VersionReport::Relayed(4).resolve(Some(3)), 4);
// The sender's own entry is a self-report and may lower the version.
let own = VersionReport::for_listed(&profile("tui_a", 3), Some("tui_a"));
assert_eq!(own, VersionReport::SelfReported(Some(3)));
assert_eq!(own.resolve(Some(4)), 3);
// Profiles without a version (pending pairing, pre-v4 DeviceProfileSet)
// keep the stored value, or the unreported version 1.
assert_eq!(VersionReport::SelfReported(None).resolve(Some(4)), 4);
assert_eq!(VersionReport::SelfReported(None).resolve(None), 1);
}
#[test]
fn podcast_snapshot_sections_are_bounded_per_message() {
let mut snapshot = SyncSnapshot::default();
let progress = music_dht::podcast::ProgressRecord {
episode_id: episode_id(),
podcast_id: podcast_id(),
position_ms: 1,
status: ProgressStatus::InProgress,
generation: 1,
session_id: "s".into(),
hlc_ms: 1,
device_id: "tui_a".into(),
op_id: "tui_a:1".into(),
};
snapshot.podcast_progress = vec![progress; 10];
// Large other parts leave (almost) no budget for podcast sections.
let big_title = "x".repeat(music_dht::device_sync::MAX_SYNC_LINE - 16 * 1024);
let mut message = WireMessage::Hello {
group_id: "g".into(),
profile: DeviceProfileWire {
device_id: "web".into(),
name: big_title,
client_version: String::new(),
protocol_version: PROTOCOL_VERSION,
endpoint_id: String::new(),
endpoint_ticket: String::new(),
revoked: false,
revoke_cutoff_seq: None,
updated_at_ms: 0,
},
devices: vec![],
vector: BTreeMap::new(),
ops: vec![],
snapshot: snapshot.clone(),
playback: None,
};
fit_podcast_snapshot(&mut message);
let WireMessage::Hello {
snapshot: fitted, ..
} = &message
else {
unreachable!()
};
assert!(fitted.podcast_progress.is_empty());
let mut small = WireMessage::SyncResponse {
accepted: true,
error: None,
devices: vec![],
vector: BTreeMap::new(),
ops: vec![],
snapshot,
playback: None,
};
fit_podcast_snapshot(&mut small);
let WireMessage::SyncResponse { snapshot, .. } = &small else {
unreachable!()
};
assert_eq!(snapshot.podcast_progress.len(), 10);
}
/// Pool that is never connected: the bridge paths under test resolve
/// podcast items, placeholders and inline content ids without queries.
fn offline_pool() -> sqlx::PgPool {
sqlx::postgres::PgPoolOptions::new()
.connect_lazy("postgres://offline@127.0.0.1:1/offline")
.unwrap()
}
#[tokio::test]
async fn podcast_queue_survives_server_browser_server_round_trip() {
let pool = offline_pool();
let mut other = test_episode();
other.episode_title = "Episode 43".into();
other.episode_id = EpisodeId::from_guid(&other.podcast_id, "episode-43").unwrap();
let mut unresolved = music_track(0);
unresolved.title = "Remote song".into();
let queue = vec![
PlaybackTrack::podcast_episode(test_episode()),
PlaybackTrack::private_placeholder(),
unresolved,
PlaybackTrack::podcast_episode(other),
];
let mut incoming = state(queue.clone());
incoming.queue_pos = 3;
incoming.paused = true;
incoming.position_secs = 1200.0;
// peer -> server -> browser
let payload = web_playback_payload(&pool, &incoming).await.unwrap();
let tracks = payload["tracks"].as_array().unwrap();
assert_eq!(tracks.len(), 4, "no item is dropped");
assert_eq!(payload["index"], 3);
assert_eq!(payload["position_seconds"], 1200.0);
assert_eq!(tracks[0]["source"]["kind"], "podcast_episode");
assert_eq!(tracks[0]["unavailable"], true);
assert_eq!(tracks[1]["source"]["kind"], "private");
// The browser keeps its queue and sends it back (plus a library track
// it added at the end, with its content id inline).
let mut browser: serde_json::Value = serde_json::from_str(&payload.to_string()).unwrap();
browser["tracks"]
.as_array_mut()
.unwrap()
.push(serde_json::json!({
"id": 77, "title": "Library song", "content_id": CONTENT_ID,
"duration_seconds": 100.0, "artists": [{"id": 1, "name": "A"}],
"release_id": 9, "release_title": "Album",
}));
// browser -> server -> peer
let outgoing = playback_state_from_browser_json(&pool, 1, browser)
.await
.unwrap();
assert_eq!(outgoing.queue[..4], queue[..]);
assert_eq!(outgoing.queue_pos, 3);
assert!(outgoing.paused);
// The episode position goes back to the peer (handoff web -> TUI).
assert_eq!(outgoing.position_secs, 1200.0);
let library = &outgoing.queue[4];
assert_eq!(library.id, 77);
assert_eq!(library.content_id.as_deref(), Some(CONTENT_ID));
assert_eq!(library.source, None);
// Library music keeps the v3 shape.
assert!(!serde_json::to_string(library).unwrap().contains("source"));
// Peers below v4 get no playback snapshot with these items.
assert!(!playback_allowed_for_peer(&outgoing, 3));
assert!(playback_allowed_for_peer(&outgoing, 4));
}
#[tokio::test]
async fn malformed_browser_items_keep_the_position_on_its_item() {
let pool = offline_pool();
let browser = serde_json::json!({
"tracks": [
{"title": "no id"},
{"id": 5, "content_id": CONTENT_ID},
{"id": 6, "content_id": CONTENT_ID},
],
"index": 2,
"track": {"id": 6},
});
let wire = playback_state_from_browser_json(&pool, 1, browser)
.await
.unwrap();
assert_eq!(wire.queue.len(), 2);
assert_eq!(wire.queue[wire.queue_pos].id, 6);
}
fn progress_record(position_ms: i64, status: ProgressStatus, generation: u64) -> ProgressRecord {
let episode = test_episode();
ProgressRecord {
episode_id: episode.episode_id,
podcast_id: episode.podcast_id,
position_ms,
status,
generation,
session_id: "session-1".into(),
hlc_ms: 1_700_000_000_000,
device_id: "tui".into(),
op_id: "op-1".into(),
}
}
/// Browser state of `[library song, episode]` with the song current at 200 s.
fn song_then_episode() -> serde_json::Value {
let episode = PlaybackTrack::podcast_episode(test_episode());
let song = serde_json::json!({
"id": 77, "title": "Library song", "content_id": CONTENT_ID,
"duration_seconds": 300.0, "stream_url": "/api/player/stream/77",
});
serde_json::json!({
"tracks": [song.clone(), queue_items::external_track_json(&episode, 1, None)],
"index": 0,
"track": song,
"position_seconds": 200.0,
"paused": false,
"repeat_mode": "off",
})
}
fn position_unknown(state: &serde_json::Value) -> bool {
state[queue_items::POSITION_UNKNOWN_KEY] == true
}
#[test]
fn commands_that_select_an_item_do_not_know_its_position() {
let current = song_then_episode();
// Next and Prev onto another item, and play commands (which the browser
// always sends with position 0), leave the position to the server.
let next =
browser_state_for_command("next", serde_json::json!({}), Some(current.clone())).unwrap();
assert_eq!(next["index"], 1);
assert_eq!(next["position_seconds"], 0.0);
assert!(position_unknown(&next));
let mut play = current.clone();
play["index"] = serde_json::json!(1);
let played = browser_state_for_command("play_from_index", play.clone(), None).unwrap();
assert!(position_unknown(&played));
let prev =
browser_state_for_command("prev", serde_json::json!({}), Some(next.clone())).unwrap();
assert_eq!(prev["index"], 0);
assert!(position_unknown(&prev));
// Restarting the same item and seeking are explicit positions.
let mut late = next.clone();
late["position_seconds"] = serde_json::json!(900.0);
let restart = browser_state_for_command("prev", serde_json::json!({}), Some(late)).unwrap();
assert_eq!(restart["index"], 1);
assert!(!position_unknown(&restart));
let repeat = browser_state_for_command(
"next",
serde_json::json!({"repeat_mode": "one"}),
Some(next.clone()),
)
.unwrap();
assert!(!position_unknown(&repeat));
let seek =
browser_state_for_command("seek", serde_json::json!({"time": 60.0}), Some(next)).unwrap();
assert_eq!(seek["position_seconds"], 60.0);
assert!(!position_unknown(&seek));
// A transfer keeps what the sender knew.
let mut handed_off = play;
handed_off["position_seconds"] = serde_json::json!(1200.0);
let transfer = browser_state_for_command("transfer_state", handed_off.clone(), None).unwrap();
assert_eq!(transfer["position_seconds"], 1200.0);
assert!(!position_unknown(&transfer));
handed_off[queue_items::POSITION_UNKNOWN_KEY] = serde_json::json!(true);
let transfer = browser_state_for_command("transfer_state", handed_off, None).unwrap();
assert!(position_unknown(&transfer));
}
#[tokio::test]
async fn unknown_episode_position_resumes_from_the_progress_register() {
let pool = offline_pool();
let next = browser_state_for_command("next", serde_json::json!({}), Some(song_then_episode()))
.unwrap();
let mut wire = browser_json_to_wire(&pool, next).await.unwrap();
assert_eq!(wire.queue_pos, 1);
assert_eq!(wire.position_secs, 0.0);
// In progress at 1200 s, generation 9 (the queue item has seen 7).
let mut resumed = wire.clone();
apply_resume_position(
&mut resumed,
Some(&progress_record(1_200_000, ProgressStatus::InProgress, 9)),
);
assert_eq!(resumed.position_secs, 1200.0);
let episode = resumed.queue[1].podcast_episode_ref().unwrap();
assert_eq!(episode.progress_generation, Some(9));
// The receiver's explicit write then orders after the register.
assert_eq!(
ProgressRecord::explicit_generation(episode.progress_generation),
10
);
// Completed: ordinary Play starts from the beginning; an older register
// does not lower the generation the item has seen.
let mut completed = wire.clone();
apply_resume_position(
&mut completed,
Some(&progress_record(1_790_000, ProgressStatus::Completed, 3)),
);
assert_eq!(completed.position_secs, 0.0);
assert_eq!(
completed.queue[1]
.podcast_episode_ref()
.unwrap()
.progress_generation,
Some(7)
);
// Music keeps the position it has.
wire.queue_pos = 0;
wire.position_secs = 5.0;
let before = wire.clone();
apply_resume_position(
&mut wire,
Some(&progress_record(1_200_000, ProgressStatus::InProgress, 9)),
);
assert_eq!(wire, before);
}
#[tokio::test]
async fn known_positions_and_music_never_read_the_progress_register() {
// The offline pool fails any query, so these conversions must not query.
let pool = offline_pool();
let mut handed_off = song_then_episode();
handed_off["index"] = serde_json::json!(1);
handed_off["position_seconds"] = serde_json::json!(1200.0);
let wire = playback_state_from_browser_json(&pool, 1, handed_off)
.await
.unwrap();
assert_eq!(wire.position_secs, 1200.0);
let mut music = song_then_episode();
music[queue_items::POSITION_UNKNOWN_KEY] = serde_json::json!(true);
let wire = playback_state_from_browser_json(&pool, 1, music)
.await
.unwrap();
assert_eq!(wire.position_secs, 200.0);
}
+3 -1
View File
@@ -1,5 +1,6 @@
//! Cross-binary protocol contract; the peer is the TUI's production adapter.
use super::*;
use music_dht::device_sync::read_line;
use tokio::io::AsyncWriteExt;
#[tokio::test]
@@ -34,7 +35,8 @@ async fn localhost_tui_peer() {
else {
panic!("expected TUI hello")
};
assert_eq!(profile.protocol_version, PROTOCOL_VERSION);
// TUI 0.3.x reports v3; podcast-capable TUI releases report v4.
assert!((3..=PROTOCOL_VERSION).contains(&profile.protocol_version));
assert_eq!(snapshot.device_id, profile.device_id);
let announcement = snapshot
.coordination
+478
View File
@@ -0,0 +1,478 @@
//! Device-sync v4 storage paths against PostgreSQL.
//!
//! Requires a migrated disposable database (start the server once against
//! it); the test writes rows for a random user id and removes them again.
use super::*;
use crate::player::queue_items::test_episode;
use music_dht::podcast::{
EpisodeId, FeedUrl, PodcastId, PodcastMeta, ProgressRecord, ProgressStatus, ShareRecord,
};
fn profile(device_id: &str, protocol_version: u16) -> DeviceProfileWire {
DeviceProfileWire {
device_id: device_id.into(),
name: device_id.to_uppercase(),
client_version: "test".into(),
protocol_version,
endpoint_id: String::new(),
endpoint_ticket: String::new(),
revoked: false,
revoke_cutoff_seq: None,
updated_at_ms: now_ms(),
}
}
fn op(origin: &str, seq: i64, hlc_ms: i64, payload: SyncOpPayload) -> SyncOpWire {
SyncOpWire {
op_id: format!("{origin}:{seq}"),
origin_device_id: origin.into(),
seq,
hlc_ms,
payload,
}
}
async fn cleanup(pool: &sqlx::PgPool, user_id: i64) {
for table in [
"furumusic__fed_device_identity",
"furumusic__fed_device",
"furumusic__fed_device_invite",
"furumusic__fed_peer_ack",
"furumusic__fed_pending_pairing",
"furumusic__fed_playback_applied",
"furumusic__fed_podcast_relay",
"furumusic__fed_state_like",
"furumusic__fed_state_playlist",
"furumusic__fed_state_playlist_item",
"furumusic__fed_sync_ops",
"furumusic__fed_sync_vector",
"furumusic__playback_state",
] {
sqlx::query(&format!("DELETE FROM {table} WHERE user_id = $1"))
.bind(user_id)
.execute(pool)
.await
.unwrap();
}
}
#[tokio::test]
#[ignore = "requires a migrated disposable database in FURU_DEVICE_SYNC_TEST_DATABASE_URL"]
async fn postgres_podcast_relay_gating_and_peer_versions() {
let pool = sqlx::PgPool::connect(&std::env::var("FURU_DEVICE_SYNC_TEST_DATABASE_URL").unwrap())
.await
.unwrap();
let user_id = 8_000_000_000 + i64::from(rand_suffix());
cleanup(&pool, user_id).await;
let new = format!("tui_new_{user_id}");
let old = format!("tui_old_{user_id}");
let other = format!("tui_other_{user_id}");
let identity = ensure_identity(&pool, user_id, "tester").await.unwrap();
// Peer versions: self-reports replace, relayed profiles only raise.
for (device, version) in [(&new, 4), (&old, 3), (&other, 4)] {
apply_device_profile(
&pool,
user_id,
&profile(device, version),
VersionReport::SelfReported(Some(version)),
true,
)
.await
.unwrap();
}
// A v3 relay lists everyone with its own constant.
apply_device_profiles(
&pool,
user_id,
&[profile(&new, 3), profile(&old, 3)],
Some(old.as_str()),
)
.await
.unwrap();
assert_eq!(
stored_protocol_version(&pool, user_id, &new).await.unwrap(),
4
);
assert_eq!(
stored_protocol_version(&pool, user_id, &old).await.unwrap(),
3
);
// Podcast and music operations from the v4 device.
let feed = FeedUrl::parse("https://podcasts.example/feed.xml").unwrap();
let podcast_id = PodcastId::from_feed_url(&feed);
let episode_id = EpisodeId::from_guid(&podcast_id, "ep-1").unwrap();
let meta: PodcastMeta = serde_json::from_value(serde_json::json!({
"feed_url": feed.as_str(), "title": "Example Cast"
}))
.unwrap();
let progress = |seq, generation, hlc_ms, position_ms| {
op(
&new,
seq,
hlc_ms,
SyncOpPayload::PodcastProgressSet {
episode_id: episode_id.clone(),
podcast_id: podcast_id.clone(),
position_ms,
status: ProgressStatus::InProgress,
generation,
session_id: format!("s{generation}"),
episode: None,
},
)
};
let mut invalid = progress(5, 9, 50, 1);
if let SyncOpPayload::PodcastProgressSet { session_id, .. } = &mut invalid.payload {
session_id.clear();
}
let hub = Arc::new(PlayerDeviceHub::default());
apply_ops(
&pool,
Arc::clone(&hub),
user_id,
vec![
op(
&new,
1,
10,
SyncOpPayload::PodcastSubscriptionSet {
podcast_id: podcast_id.clone(),
subscribed: true,
podcast: meta,
feed_aliases: vec![],
generation: 1,
},
),
// Newer generation first, then a late checkpoint of an older one.
progress(2, 4, 20, 10_000),
progress(3, 3, 90_000, 600_000),
op(
&new,
4,
40,
SyncOpPayload::TrackLikeSet {
content_id: format!("b3:{}", "3".repeat(64)),
liked: false,
fed: None,
},
),
invalid,
],
)
.await
.unwrap();
// The invalid operation is not stored but acknowledged.
assert_eq!(vector(&pool, user_id).await.unwrap().get(&new), Some(&5));
let stored: i64 = sqlx::query_scalar(
"SELECT COUNT(*) FROM furumusic__fed_sync_ops WHERE user_id = $1 AND origin_device_id = $2",
)
.bind(user_id)
.bind(&new)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(stored, 4);
// Relay: the v3 peer gets only music, a v4 peer gets everything.
let kinds = |ops: Vec<SyncOpWire>| {
ops.iter()
.map(|op| payload_kind(&op.payload))
.collect::<Vec<_>>()
};
let to_old = kinds(ops_for_peer(&pool, user_id, &old, 3).await.unwrap());
assert!(to_old.iter().all(|kind| !kind.starts_with("podcast_")));
assert!(to_old.contains(&"track_like_set"));
let to_other = kinds(ops_for_peer(&pool, user_id, &other, 4).await.unwrap());
assert_eq!(
to_other
.iter()
.filter(|kind| kind.starts_with("podcast_"))
.count(),
3
);
// Snapshot recovery: registers merged with the shared rules.
apply_snapshot(
&pool,
user_id,
SyncSnapshot {
podcast_shares: vec![ShareRecord {
podcast_id: podcast_id.clone(),
shared: false,
generation: 2,
hlc_ms: 60,
op_id: format!("{other}:1"),
}],
podcast_progress: vec![ProgressRecord {
episode_id: episode_id.clone(),
podcast_id: podcast_id.clone(),
position_ms: 1,
status: ProgressStatus::InProgress,
generation: 2,
session_id: "old".into(),
hlc_ms: 999_999,
device_id: other.clone(),
op_id: format!("{other}:2"),
}],
..SyncSnapshot::default()
},
)
.await
.unwrap();
let full = snapshot(&pool, user_id).await.unwrap();
assert_eq!(full.podcast_subscriptions.len(), 1);
assert_eq!(full.podcast_shares.len(), 1);
assert_eq!(full.podcast_progress.len(), 1);
assert_eq!(full.podcast_progress[0].position_ms, 10_000);
assert_eq!(full.podcast_progress[0].generation, 4);
assert!(!full.for_peer(3).has_podcast_state());
assert_eq!(full.for_peer(4), full);
// A DeviceProfileSet with a version is a self-report of its origin.
apply_ops(
&pool,
Arc::clone(&hub),
user_id,
vec![op(
&old,
1,
70,
SyncOpPayload::DeviceProfileSet {
name: "OLD".into(),
client_version: "0.4.0".into(),
endpoint_ticket: String::new(),
endpoint_id: String::new(),
protocol_version: Some(4),
},
)],
)
.await
.unwrap();
assert_eq!(
stored_protocol_version(&pool, user_id, &old).await.unwrap(),
4
);
// First start after the upgrade announces the new version once.
sqlx::query(
"UPDATE furumusic__fed_device SET protocol_version = 3
WHERE user_id = $1 AND device_id = $2",
)
.bind(user_id)
.bind(&identity.device_id)
.execute(&pool)
.await
.unwrap();
own_profile(&pool, user_id, "", "").await.unwrap();
own_profile(&pool, user_id, "", "").await.unwrap();
let announced: Vec<serde_json::Value> = sqlx::query_scalar(
"SELECT payload_json FROM furumusic__fed_sync_ops
WHERE user_id = $1 AND origin_device_id = $2 AND kind = 'device_profile_set'",
)
.bind(user_id)
.bind(&identity.device_id)
.fetch_all(&pool)
.await
.unwrap();
assert_eq!(announced.len(), 1);
assert_eq!(announced[0]["protocol_version"], 4);
// Handoff gating: refused for the v3 device, allowed for v4.
let queue = PlaybackStateWire {
queue: vec![PlaybackTrack::podcast_episode(test_episode())],
queue_pos: 0,
playing: true,
paused: false,
idle_since_ms: None,
position_secs: 0.0,
volume: 50,
shuffle: false,
repeat: PlaybackRepeat::Off,
playback_rate: None,
};
sqlx::query(
"UPDATE furumusic__fed_device SET protocol_version = 3
WHERE user_id = $1 AND device_id = $2",
)
.bind(user_id)
.bind(&old)
.execute(&pool)
.await
.unwrap();
let refused = ensure_playback_supported_by(&pool, user_id, &old, &queue)
.await
.unwrap_err();
assert!(refused.to_string().contains("needs an update"));
ensure_playback_supported_by(&pool, user_id, &other, &queue)
.await
.unwrap();
// The typed queue column exists next to queue_json.
sqlx::query("SELECT queue_json, queue_items_json FROM furumusic__playback_state LIMIT 0")
.execute(&pool)
.await
.unwrap();
cleanup(&pool, user_id).await;
}
#[tokio::test]
#[ignore = "requires a migrated disposable database in FURU_DEVICE_SYNC_TEST_DATABASE_URL"]
async fn postgres_unknown_episode_position_and_rollback_cleanup() {
let pool = sqlx::PgPool::connect(&std::env::var("FURU_DEVICE_SYNC_TEST_DATABASE_URL").unwrap())
.await
.unwrap();
let user_id = 8_000_000_000 + i64::from(rand_suffix());
cleanup(&pool, user_id).await;
let tui = format!("tui_{user_id}");
ensure_identity(&pool, user_id, "tester").await.unwrap();
apply_device_profile(
&pool,
user_id,
&profile(&tui, 4),
VersionReport::SelfReported(Some(4)),
true,
)
.await
.unwrap();
// The TUI left the episode at 1200 s (generation 9; queue items saw 7).
let episode = test_episode();
let hub = Arc::new(PlayerDeviceHub::default());
apply_ops(
&pool,
Arc::clone(&hub),
user_id,
vec![op(
&tui,
1,
10,
SyncOpPayload::PodcastProgressSet {
episode_id: episode.episode_id.clone(),
podcast_id: episode.podcast_id.clone(),
position_ms: 1_200_000,
status: ProgressStatus::InProgress,
generation: 9,
session_id: "s9".into(),
episode: None,
},
)],
)
.await
.unwrap();
// The web player reached the episode by Next and does not know where it
// was left; it hands playback to the TUI.
let song = serde_json::json!({
"id": 77, "title": "Library song", "content_id": format!("b3:{}", "4".repeat(64)),
"duration_seconds": 300.0,
});
let item = crate::player::queue_items::external_track_json(
&PlaybackTrack::podcast_episode(episode.clone()),
1,
None,
);
let browser = serde_json::json!({
"tracks": [song.clone(), item.clone()], "index": 1, "track": item.clone(),
"position_seconds": 0.0, "paused": true, "position_unknown": true,
});
record_web_active_transfer(&pool, user_id, &tui, None, browser)
.await
.unwrap();
let sent: serde_json::Value = sqlx::query_scalar(
"SELECT payload_json FROM furumusic__fed_sync_ops
WHERE user_id = $1 AND kind = 'playback_command' ORDER BY seq DESC LIMIT 1",
)
.bind(user_id)
.fetch_one(&pool)
.await
.unwrap();
let SyncOpPayload::PlaybackCommand {
command: PlaybackCommand::ActiveChanged { state, .. },
..
} = serde_json::from_value(sent).unwrap()
else {
panic!("expected ActiveChanged");
};
assert_eq!(state.position_secs, 1200.0, "never 0");
assert_eq!(
state.queue[1]
.podcast_episode_ref()
.unwrap()
.progress_generation,
Some(9)
);
// Remote Next onto the episode while the TUI plays the song.
let current = serde_json::json!({
"tracks": [song, item], "index": 0, "track": song,
"position_seconds": 200.0, "paused": false,
});
let next = record_web_playback_command(
&pool,
user_id,
&tui,
"next",
serde_json::json!({}),
Some(current),
)
.await
.unwrap();
assert_eq!(next["index"], 1);
assert_eq!(next["position_seconds"], 1200.0);
assert!(
next.get(crate::player::queue_items::POSITION_UNKNOWN_KEY)
.is_none()
);
// Rollback to 0.12: its types fail on the relayed podcast operation, and
// parse everything once the documented cleanup ran.
let parse_like_0_12 = |rows: Vec<serde_json::Value>| {
rows.into_iter()
.map(serde_json::from_value::<super::wire_compat_tests::legacy::SyncOpPayload>)
.collect::<Result<Vec<_>, _>>()
};
let rows = || async {
sqlx::query_scalar::<_, serde_json::Value>(
"SELECT payload_json FROM furumusic__fed_sync_ops WHERE user_id = $1",
)
.bind(user_id)
.fetch_all(&pool)
.await
.unwrap()
};
assert!(parse_like_0_12(rows().await).is_err());
sqlx::query(&format!(
"{} AND user_id = $1",
crate::music::db_migrations::DELETE_PODCAST_SYNC_OPS_SQL
))
.bind(user_id)
.execute(&pool)
.await
.unwrap();
let remaining = parse_like_0_12(rows().await).unwrap();
// The playback commands (with the episode's `source`) stay readable.
assert_eq!(
remaining
.iter()
.filter(|payload| matches!(
payload,
super::wire_compat_tests::legacy::SyncOpPayload::PlaybackCommand { .. }
))
.count(),
2
);
cleanup(&pool, user_id).await;
}
fn rand_suffix() -> u32 {
u32::from_le_bytes(
blake3::hash(random_hex(8).as_bytes()).as_bytes()[..4]
.try_into()
.unwrap(),
) % 1_000_000_000
}
+524
View File
@@ -0,0 +1,524 @@
//! Golden wire-compatibility tests: the shared `music_dht::device_sync`
//! types must serialize v3 content byte-for-byte like the private copies that
//! furumi-web 0.12.x used (kept verbatim in `legacy` below), so TUI 0.3.x and
//! older web servers keep interoperating.
use super::*;
/// Private wire types of furumi-web 0.12.4 (`src/federation/devices.rs`),
/// copied verbatim apart from visibility and `PartialEq`.
#[allow(dead_code)]
pub(super) mod legacy {
use music_dht::device_sync::ListenEvent;
use music_dht::playback::CommandStamp;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InviteWire {
pub v: u16,
#[serde(rename = "t")]
pub ticket: String,
#[serde(rename = "d")]
pub device_id: String,
#[serde(rename = "i")]
pub invite_id: String,
#[serde(rename = "s")]
pub secret: String,
#[serde(rename = "e")]
pub expires_at_ms: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DeviceProfileWire {
pub device_id: String,
pub name: String,
pub client_version: String,
pub protocol_version: u16,
pub endpoint_id: String,
pub endpoint_ticket: String,
#[serde(default)]
pub revoked: bool,
#[serde(default)]
pub revoke_cutoff_seq: Option<i64>,
#[serde(default)]
pub updated_at_ms: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SyncedFedTrack {
pub item_id: String,
pub owner: String,
pub title: String,
#[serde(default)]
pub artist_names: Vec<String>,
#[serde(default)]
pub featured_artist_names: Vec<String>,
pub year: Option<i32>,
pub duration_seconds: Option<i64>,
pub content_id: String,
pub release_title: Option<String>,
pub track_number: Option<i32>,
pub disc_number: Option<i32>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlaybackTrack {
pub id: i64,
pub title: String,
pub track_number: Option<i32>,
pub disc_number: Option<i32>,
pub duration_seconds: f64,
#[serde(default)]
pub artist_names: Vec<String>,
#[serde(default)]
pub featured_artist_names: Vec<String>,
pub release_id: i64,
pub release_title: String,
pub release_year: Option<i32>,
#[serde(default)]
pub file_path: String,
pub content_id: Option<String>,
pub audio_format: Option<String>,
pub audio_bitrate: Option<i32>,
pub audio_sample_rate: Option<i32>,
pub audio_bit_depth: Option<i32>,
pub file_size_bytes: Option<i64>,
#[serde(default)]
pub play_count: i64,
#[serde(default)]
pub fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum PlaybackRepeat {
#[default]
Off,
One,
All,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlaybackStateWire {
#[serde(default)]
pub queue: Vec<PlaybackTrack>,
#[serde(default)]
pub queue_pos: usize,
pub playing: bool,
pub paused: bool,
#[serde(default)]
pub idle_since_ms: Option<i64>,
pub position_secs: f64,
#[serde(default)]
pub volume: u8,
pub shuffle: bool,
pub repeat: PlaybackRepeat,
}
pub type PlaybackSnapshot = music_dht::playback::Snapshot<PlaybackStateWire>;
pub type PlaybackCommand = music_dht::playback::Command<PlaybackStateWire>;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncOpWire {
pub op_id: String,
pub origin_device_id: String,
pub seq: i64,
pub hlc_ms: i64,
pub payload: SyncOpPayload,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum SyncOpPayload {
TrackLikeSet {
content_id: String,
liked: bool,
#[serde(default)]
fed: Option<SyncedFedTrack>,
},
PlaylistCreated {
playlist_id: String,
title: String,
},
PlaylistRenamed {
playlist_id: String,
title: String,
},
PlaylistDeleted {
playlist_id: String,
},
PlaylistTrackAdded {
playlist_id: String,
content_id: String,
position: i64,
#[serde(default)]
fed: Option<SyncedFedTrack>,
},
PlaylistTrackRemoved {
playlist_id: String,
content_id: String,
},
DeviceProfileSet {
name: String,
client_version: String,
endpoint_ticket: String,
endpoint_id: String,
},
DeviceTrusted {
target_device_id: String,
},
DeviceRevoked {
target_device_id: String,
target_max_seq_seen: i64,
},
PlaybackCommand {
target_device_id: String,
command: PlaybackCommand,
#[serde(default)]
authority: Option<CommandStamp>,
},
ListenRecorded {
event: ListenEvent,
},
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SyncSnapshot {
#[serde(default)]
pub likes: Vec<SnapshotLike>,
#[serde(default)]
pub unlikes: Vec<SnapshotLikeTombstone>,
#[serde(default)]
pub playlists: Vec<SnapshotPlaylist>,
#[serde(default)]
pub deleted_playlists: Vec<SnapshotPlaylistTombstone>,
#[serde(default)]
pub removed_playlist_items: Vec<SnapshotPlaylistItemTombstone>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotLike {
pub content_id: String,
pub hlc_ms: i64,
pub op_id: String,
#[serde(default)]
pub fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotLikeTombstone {
pub content_id: String,
pub hlc_ms: i64,
pub op_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPlaylist {
pub playlist_id: String,
pub title: String,
pub hlc_ms: i64,
pub op_id: String,
#[serde(default)]
pub items: Vec<SnapshotPlaylistItem>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPlaylistTombstone {
pub playlist_id: String,
pub hlc_ms: i64,
pub op_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPlaylistItem {
pub content_id: String,
pub position: i64,
pub hlc_ms: i64,
pub op_id: String,
#[serde(default)]
pub fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPlaylistItemTombstone {
pub playlist_id: String,
pub content_id: String,
pub hlc_ms: i64,
pub op_id: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum WireMessage {
PairRequest {
invite_id: String,
secret: String,
profile: DeviceProfileWire,
#[serde(default)]
group_id: Option<String>,
#[serde(default)]
group_active_devices: usize,
#[serde(default)]
devices: Vec<DeviceProfileWire>,
vector: BTreeMap<String, i64>,
ops: Vec<SyncOpWire>,
snapshot: SyncSnapshot,
#[serde(default)]
playback: Option<PlaybackSnapshot>,
},
PairResponse {
accepted: bool,
#[serde(default)]
pending: bool,
#[serde(default)]
error: Option<String>,
#[serde(default)]
group_id: Option<String>,
#[serde(default)]
profile: Option<DeviceProfileWire>,
#[serde(default)]
devices: Vec<DeviceProfileWire>,
#[serde(default)]
vector: BTreeMap<String, i64>,
#[serde(default)]
ops: Vec<SyncOpWire>,
#[serde(default)]
snapshot: SyncSnapshot,
#[serde(default)]
playback: Option<PlaybackSnapshot>,
},
Hello {
group_id: String,
profile: DeviceProfileWire,
devices: Vec<DeviceProfileWire>,
vector: BTreeMap<String, i64>,
ops: Vec<SyncOpWire>,
snapshot: SyncSnapshot,
#[serde(default)]
playback: Option<PlaybackSnapshot>,
},
SyncResponse {
accepted: bool,
#[serde(default)]
error: Option<String>,
#[serde(default)]
devices: Vec<DeviceProfileWire>,
#[serde(default)]
vector: BTreeMap<String, i64>,
#[serde(default)]
ops: Vec<SyncOpWire>,
#[serde(default)]
snapshot: SyncSnapshot,
#[serde(default)]
playback: Option<PlaybackSnapshot>,
},
}
}
const CONTENT_ID: &str = "b3:1111111111111111111111111111111111111111111111111111111111111111";
/// A v3 `hello` exercising every v3 operation kind, every snapshot section
/// and a coordinated playback snapshot (input order is irrelevant).
fn v3_hello_input() -> String {
let fed = serde_json::json!({
"item_id": "item", "owner": "owner", "title": "Song", "artist_names": ["A"],
"featured_artist_names": [], "year": 2001, "duration_seconds": 180,
"content_id": CONTENT_ID, "release_title": "Album", "track_number": 1, "disc_number": 1,
});
let track = serde_json::json!({
"id": 7, "title": "Song", "track_number": 1, "disc_number": null,
"duration_seconds": 180.5, "artist_names": ["A"], "featured_artist_names": ["B"],
"release_id": 3, "release_title": "Album", "release_year": 2001, "file_path": "",
"content_id": CONTENT_ID, "audio_format": "flac", "audio_bitrate": 900,
"audio_sample_rate": 44100, "audio_bit_depth": 16, "file_size_bytes": 12345,
"play_count": 2, "fed": fed,
});
let state = serde_json::json!({
"queue": [track, {"id": 0, "title": "Remote", "track_number": null, "disc_number": null,
"duration_seconds": 0.0, "release_id": 0, "release_title": "", "release_year": null,
"content_id": null, "audio_format": null, "audio_bitrate": null,
"audio_sample_rate": null, "audio_bit_depth": null, "file_size_bytes": null}],
"queue_pos": 1, "playing": true, "paused": false, "idle_since_ms": null,
"position_secs": 42.5, "volume": 73, "shuffle": true, "repeat": "all",
});
let claim = serde_json::json!({"counter": 3, "issuer": "tui_a", "owner": "tui_a"});
let stamp = serde_json::json!({"version": 1, "claim": claim, "sequence": 9});
let op = |seq: i64, payload: serde_json::Value| {
serde_json::json!({"op_id": format!("tui_a:{seq}"), "origin_device_id": "tui_a",
"seq": seq, "hlc_ms": 1_700_000_000_000i64 + seq, "payload": payload})
};
let profile = |id: &str| {
serde_json::json!({"device_id": id, "name": "TUI", "client_version": "0.3.4",
"protocol_version": 3, "endpoint_id": "e", "endpoint_ticket": "t",
"revoked": false, "revoke_cutoff_seq": null, "updated_at_ms": 5})
};
serde_json::json!({
"type": "hello",
"group_id": "grp_1",
"profile": profile("tui_a"),
"devices": [profile("tui_a"), profile("web_b")],
"vector": {"tui_a": 12, "web_b": 4},
"ops": [
op(1, serde_json::json!({"kind": "track_like_set", "content_id": CONTENT_ID, "liked": true, "fed": fed})),
op(2, serde_json::json!({"kind": "playlist_created", "playlist_id": "pl", "title": "Mix"})),
op(3, serde_json::json!({"kind": "playlist_renamed", "playlist_id": "pl", "title": "Mix 2"})),
op(4, serde_json::json!({"kind": "playlist_track_added", "playlist_id": "pl", "content_id": CONTENT_ID, "position": 0, "fed": null})),
op(5, serde_json::json!({"kind": "playlist_track_removed", "playlist_id": "pl", "content_id": CONTENT_ID})),
op(6, serde_json::json!({"kind": "playlist_deleted", "playlist_id": "pl"})),
op(7, serde_json::json!({"kind": "device_profile_set", "name": "TUI", "client_version": "0.3.4", "endpoint_ticket": "t", "endpoint_id": "e"})),
op(8, serde_json::json!({"kind": "device_trusted", "target_device_id": "web_b"})),
op(9, serde_json::json!({"kind": "device_revoked", "target_device_id": "old", "target_max_seq_seen": 3})),
op(10, serde_json::json!({"kind": "playback_command", "target_device_id": "web_b",
"command": {"kind": "set_state", "state": state, "seek": true}, "authority": stamp})),
op(11, serde_json::json!({"kind": "playback_command", "target_device_id": "web_b",
"command": {"kind": "active_changed", "active_device_id": "web_b", "active_device_name": "WEB", "state": state}})),
op(12, serde_json::json!({"kind": "listen_recorded", "event": {"listen_id": "l1",
"content_id": CONTENT_ID, "started_at_ms": 1, "listened_ms": 60000, "track_duration_ms": 180000,
"ended_reason": "finished", "track": {"title": "Song", "artist_names": ["A"], "featured_artist_names": [], "release_title": null}}})),
],
"snapshot": {
"likes": [{"content_id": CONTENT_ID, "hlc_ms": 1, "op_id": "tui_a:1", "fed": fed}],
"unlikes": [{"content_id": CONTENT_ID, "hlc_ms": 2, "op_id": "tui_a:2"}],
"playlists": [{"playlist_id": "pl", "title": "Mix", "hlc_ms": 3, "op_id": "tui_a:3",
"items": [{"content_id": CONTENT_ID, "position": 0, "hlc_ms": 4, "op_id": "tui_a:4", "fed": null}]}],
"deleted_playlists": [{"playlist_id": "gone", "hlc_ms": 5, "op_id": "tui_a:5"}],
"removed_playlist_items": [{"playlist_id": "pl", "content_id": CONTENT_ID, "hlc_ms": 6, "op_id": "tui_a:6"}],
},
"playback": {"device_id": "tui_a", "device_name": "TUI", "active": true, "updated_at_ms": 9,
"state": state, "coordination": {"version": 1, "claim": claim, "heartbeat": 4, "available": true, "playing": true}},
})
.to_string()
}
fn v3_other_inputs() -> Vec<String> {
vec![
r#"{"type":"sync_response","accepted":false,"error":"device is not trusted"}"#.into(),
r#"{"type":"pair_response","accepted":false,"pending":true,"error":"pairing pending"}"#
.into(),
serde_json::json!({"type": "pair_request", "invite_id": "i", "secret": "s",
"profile": {"device_id": "tui_a", "name": "TUI", "client_version": "0.3.4",
"protocol_version": 3, "endpoint_id": "e", "endpoint_ticket": "t"},
"vector": {}, "ops": [], "snapshot": {}})
.to_string(),
]
}
/// Parses `input` with the 0.12.x types and the shared types and checks
/// that both serialize to the same bytes, and that each side parses the
/// other's output.
fn assert_identical(input: &str) -> String {
let old: legacy::WireMessage = serde_json::from_str(input).unwrap();
let new: WireMessage = serde_json::from_str(input).unwrap();
let old_json = serde_json::to_string(&old).unwrap();
let new_json = serde_json::to_string(&new).unwrap();
assert_eq!(old_json, new_json);
assert_eq!(
serde_json::from_str::<legacy::WireMessage>(&new_json).unwrap(),
old
);
assert_eq!(serde_json::from_str::<WireMessage>(&old_json).unwrap(), new);
new_json
}
#[test]
fn v3_messages_serialize_like_furumi_web_0_12() {
let hello = assert_identical(&v3_hello_input());
let golden = concat!(
env!("CARGO_MANIFEST_DIR"),
"/src/federation/devices/fixtures/v3_hello.golden.json"
);
if std::env::var_os("FURUMUSIC_BLESS_GOLDEN").is_some() {
// Only for a deliberate change of the v3 shape.
std::fs::write(golden, format!("{hello}\n")).unwrap();
}
assert_eq!(hello, std::fs::read_to_string(golden).unwrap().trim_end());
for input in v3_other_inputs() {
assert_identical(&input);
}
}
#[test]
fn invites_stay_readable_by_older_clients() {
let old = legacy::InviteWire {
v: 1,
ticket: "ticket".into(),
device_id: "web_a".into(),
invite_id: "inv".into(),
secret: "s3cr3t".into(),
expires_at_ms: 10,
};
let old_json = serde_json::to_string(&old).unwrap();
assert_eq!(
old_json,
r#"{"v":1,"t":"ticket","d":"web_a","i":"inv","s":"s3cr3t","e":10}"#
);
let shared: InviteWire = serde_json::from_str(&old_json).unwrap();
assert_eq!(shared.inviter_protocol_version(), 1);
assert_eq!(serde_json::to_string(&shared).unwrap(), old_json);
let link = encode_invite(&InviteWire {
protocol_version: Some(PROTOCOL_VERSION),
..shared
})
.unwrap();
let parsed = parse_invite(&link).unwrap();
assert_eq!(parsed.inviter_protocol_version(), PROTOCOL_VERSION);
// `p` is an unknown field for 0.12.x and is ignored there.
let token = link.strip_prefix("frid://i/").unwrap();
assert!(!token.is_empty());
let json = serde_json::to_string(&parsed).unwrap();
assert!(json.ends_with(r#","p":4}"#));
assert_eq!(
serde_json::from_str::<legacy::InviteWire>(&json).unwrap(),
old
);
}
#[test]
fn v3_peers_cannot_parse_podcast_operations() {
// Why podcast operations must be gated: an unknown `kind` breaks the
// whole message for a 0.12.x/TUI 0.3.x peer, not one operation.
let mut hello: serde_json::Value = serde_json::from_str(&v3_hello_input()).unwrap();
hello["ops"].as_array_mut().unwrap().push(serde_json::json!({
"op_id": "tui_a:13", "origin_device_id": "tui_a", "seq": 13, "hlc_ms": 13,
"payload": {"kind": "podcast_share_set",
"podcast_id": music_dht::podcast::PodcastId::from_feed_url(
&music_dht::podcast::FeedUrl::parse("https://podcasts.example/feed.xml").unwrap()),
"shared": false, "generation": 1},
}));
assert!(serde_json::from_value::<legacy::WireMessage>(hello.clone()).is_err());
assert!(serde_json::from_value::<WireMessage>(hello).is_ok());
}
#[test]
fn v3_peers_would_drop_the_source_of_podcast_items() {
// Why podcast playback must be gated: older types ignore `source` and
// forward the episode as a broken music item.
let episode = PlaybackTrack::podcast_episode(crate::player::queue_items::test_episode());
let json = serde_json::to_string(&episode).unwrap();
assert!(json.contains(r#""source":{"kind":"podcast_episode""#));
let old: legacy::PlaybackTrack = serde_json::from_str(&json).unwrap();
let forwarded: PlaybackTrack =
serde_json::from_str(&serde_json::to_string(&old).unwrap()).unwrap();
assert_eq!(forwarded.source, None);
assert_eq!(forwarded.id, 0);
}
#[test]
fn v4_profile_announcements_stay_readable_by_older_clients() {
let announcement = SyncOpPayload::DeviceProfileSet {
name: "WEB".into(),
client_version: "0.13.0".into(),
endpoint_ticket: "t".into(),
endpoint_id: "e".into(),
protocol_version: Some(PROTOCOL_VERSION),
};
let json = serde_json::to_string(&announcement).unwrap();
assert!(json.ends_with(r#","protocol_version":4}"#));
// 0.12.x and TUI 0.3.x ignore the new field.
let old: legacy::SyncOpPayload = serde_json::from_str(&json).unwrap();
assert!(matches!(
old,
legacy::SyncOpPayload::DeviceProfileSet { .. }
));
}
+13 -54
View File
@@ -17,6 +17,7 @@
mod capabilities;
pub mod client;
pub mod devices;
mod podcast_relay;
mod receive;
mod serve;
mod similarity;
@@ -30,7 +31,6 @@ use std::time::{Duration, Instant};
use anyhow::{Context, Result};
use music_dht::capabilities::CAPABILITIES_ALPN;
use music_dht::podcast_dht::{PODCAST_DHT_ALPN, PodcastDht};
use music_dht::similarity_dht::SimilarityDht;
use music_dht::similarity_lsh::SIMILARITY_DHT_ALPN;
use music_dht::{
@@ -61,7 +61,6 @@ const TRANSPORT_SAMPLE_LIMIT: usize = 16;
struct Running {
service: Arc<MusicDhtService>,
similarity_dht: Arc<SimilarityDht>,
podcast_dht: Arc<PodcastDht>,
network_name: String,
tasks: Vec<tokio::task::JoinHandle<()>>,
}
@@ -500,7 +499,6 @@ impl Federation {
.schema_independent_stream_protocol(SIMILARITY_ALPN)
.schema_independent_stream_protocol(SIMILARITY_DHT_ALPN)
.schema_independent_stream_protocol(CAPABILITIES_ALPN)
.schema_independent_stream_protocol(PODCAST_DHT_ALPN)
.build()
.map_err(|err| anyhow::anyhow!("invalid federation config: {err}"))?;
let (service, mut events) =
@@ -514,30 +512,6 @@ impl Federation {
"federation started"
);
let podcast_dht = PodcastDht::open(
Arc::clone(&service),
self.data_dir.join("podcast-routing.sqlite3"),
)
.await?;
let podcast_acceptor = service.stream_acceptor(PODCAST_DHT_ALPN)?;
let podcast_serve_task = tokio::spawn(Arc::clone(&podcast_dht).serve(podcast_acceptor));
let podcast_maintenance_task = tokio::spawn(Arc::clone(&podcast_dht).maintenance());
let podcast_pool = pool.clone();
let podcast_overlay = Arc::clone(&podcast_dht);
let podcast_sync_task = tokio::spawn(async move {
let mut interval = tokio::time::interval(SYNC_INTERVAL);
interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop {
interval.tick().await;
if crate::podcasts::reconcile(&podcast_pool, &podcast_overlay)
.await
.is_err()
{
tracing::warn!("podcast publication reconciliation failed; will retry");
}
}
});
let similarity_dht = SimilarityDht::open(
Arc::clone(&service),
self.data_dir.join("similarity-routing.sqlite3"),
@@ -629,12 +603,8 @@ impl Federation {
*guard = Some(Running {
service,
similarity_dht,
podcast_dht,
network_name,
tasks: vec![
podcast_serve_task,
podcast_maintenance_task,
podcast_sync_task,
event_task,
sync_task,
audio_task,
@@ -702,29 +672,6 @@ impl Federation {
.context("federation is not running")
}
pub async fn sync_podcasts(&self) -> Result<()> {
let overlay = self
.running
.lock()
.await
.as_ref()
.map(|r| Arc::clone(&r.podcast_dht))
.context("federation is not running")?;
crate::podcasts::reconcile(&self.pool().await?, &overlay).await
}
pub async fn search_podcasts(&self, query: &str) -> Result<Value> {
let overlay = self
.running
.lock()
.await
.as_ref()
.map(|r| Arc::clone(&r.podcast_dht))
.context("federation is not running")?;
let hits = overlay.search(query, 100).await?;
Ok(Value::Array(hits.into_iter().map(|hit| json!({"id":hit.podcast_id,"url":hit.feed_url,"metadata":{"title":hit.card.title,"author":hit.card.author,"description":hit.card.description,"image_url":hit.card.image_url}})).collect()))
}
async fn similarity_services(&self) -> Result<(Arc<MusicDhtService>, Arc<SimilarityDht>)> {
self.running
.lock()
@@ -1246,6 +1193,18 @@ impl Federation {
.await
}
/// Refuses a transfer that the target device cannot receive (podcast
/// items for a device below protocol v4) before ownership changes.
pub async fn fed_device_web_transfer_check(
&self,
user_id: i64,
target_device_id: &str,
state: serde_json::Value,
) -> Result<()> {
let pool = self.pool().await?;
devices::check_web_transfer(&pool, user_id, target_device_id, state).await
}
pub async fn fed_device_web_active_takeover(
&self,
user_id: i64,
+575
View File
@@ -0,0 +1,575 @@
//! Lossless relay of podcast sync state (device-sync protocol v4).
//!
//! The web server does not implement podcasts yet, but it announces protocol
//! v4 and therefore must not lose podcast state that trusted devices send
//! through it:
//!
//! * podcast operations are stored verbatim in the generic operation log
//! (`furumusic__fed_sync_ops`) and forwarded to v4 peers only;
//! * the podcast registers carried by those operations and by snapshot
//! sections are kept here as opaque JSON documents, merged with the shared
//! `music_dht::podcast` rules, and returned in this device's snapshots.
//! Snapshots are the only recovery path for a peer that skipped podcast
//! operations while it ran an older version.
//!
//! The rows hold the shared contract types (`SubscriptionRecord`,
//! `ShareRecord`, `ProgressRecord`, `ListenSession`) as JSON and nothing
//! web-specific; a later podcast store can import them.
use anyhow::Result;
use music_dht::device_sync::{SyncOpWire, SyncSnapshot};
use music_dht::podcast::{
FeedUrl, ListenSession, PodcastId, ProgressRecord, ShareRecord, SubscriptionRecord,
merge_feed_aliases, merge_listen_session, merge_progress, merge_share, merge_subscription,
};
use serde::Serialize;
use serde::de::DeserializeOwned;
use serde_json::Value;
use sqlx::Row;
const SECTION_SUBSCRIPTION: &str = "subscription";
const SECTION_SHARE: &str = "share";
const SECTION_ALIASES: &str = "aliases";
const SECTION_PROGRESS: &str = "progress";
const SECTION_SESSION: &str = "session";
/// One podcast register update, keyed by its entity.
#[derive(Debug, Clone, PartialEq)]
pub(crate) enum RelayRecord {
/// Subscription register of a podcast.
Subscription(SubscriptionRecord),
/// Share register of a podcast.
Share(ShareRecord),
/// Feed aliases learned before (or without) the subscription register.
Aliases(PodcastId, Vec<FeedUrl>),
/// Progress register of an episode.
Progress(ProgressRecord),
/// Listening session.
Session(ListenSession),
}
impl RelayRecord {
fn section(&self) -> &'static str {
match self {
RelayRecord::Subscription(_) => SECTION_SUBSCRIPTION,
RelayRecord::Share(_) => SECTION_SHARE,
RelayRecord::Aliases(..) => SECTION_ALIASES,
RelayRecord::Progress(_) => SECTION_PROGRESS,
RelayRecord::Session(_) => SECTION_SESSION,
}
}
fn key(&self) -> &str {
match self {
RelayRecord::Subscription(record) => record.podcast_id.as_str(),
RelayRecord::Share(record) => record.podcast_id.as_str(),
RelayRecord::Aliases(podcast_id, _) => podcast_id.as_str(),
RelayRecord::Progress(record) => record.episode_id.as_str(),
RelayRecord::Session(session) => session.session_id.as_str(),
}
}
/// Register updates carried by a podcast operation.
///
/// Operations that fail `validate_podcast` must be dropped before this.
pub(crate) fn from_op(op: &SyncOpWire) -> Option<Self> {
if let Some(record) = op.podcast_subscription() {
return Some(RelayRecord::Subscription(record));
}
if let Some(record) = op.podcast_share() {
return Some(RelayRecord::Share(record));
}
if let Some((podcast_id, aliases)) = op.podcast_feed_aliases() {
return Some(RelayRecord::Aliases(podcast_id.clone(), aliases.to_vec()));
}
if let Some(record) = op.podcast_progress() {
return Some(RelayRecord::Progress(record));
}
op.podcast_listen_session()
.map(|session| RelayRecord::Session(session.clone()))
}
/// Valid register records of a snapshot. Podcast sections that exceed
/// the contract counts are ignored as a whole; invalid records are
/// skipped one by one.
pub(crate) fn from_snapshot(snapshot: &SyncSnapshot) -> Vec<Self> {
if !snapshot.podcast_state_within_limits() {
tracing::debug!("ignored podcast snapshot sections above the contract limits");
return Vec::new();
}
let subscriptions = snapshot
.podcast_subscriptions
.iter()
.filter(|record| record.validate().is_ok())
.cloned()
.map(RelayRecord::Subscription);
let shares = snapshot
.podcast_shares
.iter()
.filter(|record| record.validate().is_ok())
.cloned()
.map(RelayRecord::Share);
let progress = snapshot
.podcast_progress
.iter()
.filter(|record| record.validate().is_ok())
.cloned()
.map(RelayRecord::Progress);
let sessions = snapshot
.podcast_listen_sessions
.iter()
.filter(|session| session.validate().is_ok())
.cloned()
.map(RelayRecord::Session);
subscriptions
.chain(shares)
.chain(progress)
.chain(sessions)
.collect()
}
}
/// Document address: `(section, record_key)`.
type DocKey = (&'static str, String);
/// Documents a record's merge reads.
fn read_keys(record: &RelayRecord) -> Vec<DocKey> {
let own = (record.section(), record.key().to_string());
match record {
RelayRecord::Aliases(podcast_id, _) => {
vec![(SECTION_SUBSCRIPTION, podcast_id.as_str().to_string()), own]
}
RelayRecord::Subscription(_) => {
vec![(SECTION_ALIASES, record.key().to_string()), own]
}
_ => vec![own],
}
}
/// Merges `incoming` into the stored documents with the shared rules.
///
/// Returns the writes: `Some(value)` upserts, `None` deletes. Aliases
/// learned before the subscription register are kept in their own document
/// and folded into the register when it arrives.
fn plan_merge(
docs: &std::collections::BTreeMap<DocKey, Value>,
incoming: &RelayRecord,
) -> Vec<(DocKey, Option<Value>)> {
let own = (incoming.section(), incoming.key().to_string());
let current = docs.get(&own);
let changed = |merged: Option<Value>| {
merged
.filter(|merged| current != Some(merged))
.map(|merged| (own.clone(), Some(merged)))
};
match incoming {
RelayRecord::Subscription(record) => {
let alias_key = (SECTION_ALIASES, incoming.key().to_string());
let pending = docs.get(&alias_key).and_then(parse::<Vec<FeedUrl>>);
let merged = match current.and_then(parse::<SubscriptionRecord>) {
Some(current) => merge_subscription(&current, record).ok(),
None => {
let mut record = record.clone();
record.normalize();
Some(record)
}
}
.map(|mut record| {
if let Some(aliases) = &pending {
record.add_feed_aliases(aliases);
}
record
});
let mut writes: Vec<_> = changed(merged.as_ref().and_then(to_value))
.into_iter()
.collect();
if docs.contains_key(&alias_key) && merged.is_some() {
writes.push((alias_key, None));
}
writes
}
RelayRecord::Aliases(podcast_id, aliases) => {
let sub_key = (SECTION_SUBSCRIPTION, podcast_id.as_str().to_string());
if let Some(subscription) = docs.get(&sub_key) {
let Some(mut record) = parse::<SubscriptionRecord>(subscription) else {
return Vec::new();
};
record.add_feed_aliases(aliases);
return to_value(&record)
.filter(|merged| merged != subscription)
.map(|merged| vec![(sub_key, Some(merged))])
.unwrap_or_default();
}
let current = current.and_then(parse::<Vec<FeedUrl>>).unwrap_or_default();
changed(to_value(&merge_feed_aliases(podcast_id, &current, aliases)))
.into_iter()
.collect()
}
RelayRecord::Share(record) => changed(match current.and_then(parse::<ShareRecord>) {
Some(current) => merge_share(&current, record)
.ok()
.as_ref()
.and_then(to_value),
None => to_value(record),
})
.into_iter()
.collect(),
RelayRecord::Progress(record) => changed(match current.and_then(parse::<ProgressRecord>) {
Some(current) => merge_progress(&current, record)
.ok()
.as_ref()
.and_then(to_value),
None => to_value(record),
})
.into_iter()
.collect(),
RelayRecord::Session(session) => changed(match current.and_then(parse::<ListenSession>) {
Some(current) => merge_listen_session(&current, session)
.ok()
.as_ref()
.and_then(to_value),
None => to_value(session),
})
.into_iter()
.collect(),
}
}
fn parse<T: DeserializeOwned>(value: &Value) -> Option<T> {
serde_json::from_value(value.clone()).ok()
}
fn to_value<T: Serialize>(value: &T) -> Option<Value> {
serde_json::to_value(value).ok()
}
/// Merges register updates into the user's relay state.
pub(crate) async fn merge_records(
pool: &sqlx::PgPool,
user_id: i64,
records: &[RelayRecord],
) -> Result<()> {
if records.is_empty() {
return Ok(());
}
let mut tx = pool.begin().await?;
// One writer per account: a merge reads, combines and writes documents.
sqlx::query(
"SELECT pg_advisory_xact_lock(hashtextextended('furumusic:podcast-relay:' || $1::text, 0))",
)
.bind(user_id)
.execute(&mut *tx)
.await?;
let mut docs = std::collections::BTreeMap::new();
for record in records {
for key in read_keys(record) {
if !docs.contains_key(&key)
&& let Some(value) = load(&mut tx, user_id, key.0, &key.1).await?
{
docs.insert(key, value);
}
}
for (key, value) in plan_merge(&docs, record) {
match &value {
Some(value) => store(&mut tx, user_id, key.0, &key.1, value).await?,
None => {
sqlx::query(
"DELETE FROM furumusic__fed_podcast_relay
WHERE user_id = $1 AND section = $2 AND record_key = $3",
)
.bind(user_id)
.bind(key.0)
.bind(&key.1)
.execute(&mut *tx)
.await?;
}
}
match value {
Some(value) => docs.insert(key, value),
None => docs.remove(&key),
};
}
}
tx.commit().await?;
Ok(())
}
async fn load(
tx: &mut sqlx::Transaction<'_, sqlx::Postgres>,
user_id: i64,
section: &str,
key: &str,
) -> Result<Option<Value>> {
Ok(sqlx::query_scalar(
"SELECT record_json FROM furumusic__fed_podcast_relay
WHERE user_id = $1 AND section = $2 AND record_key = $3",
)
.bind(user_id)
.bind(section)
.bind(key)
.fetch_optional(&mut **tx)
.await?)
}
async fn store(
tx: &mut sqlx::Transaction<'_, sqlx::Postgres>,
user_id: i64,
section: &str,
key: &str,
value: &Value,
) -> Result<()> {
sqlx::query(
"INSERT INTO furumusic__fed_podcast_relay
(user_id, section, record_key, record_json, updated_at_ms)
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (user_id, section, record_key) DO UPDATE SET
record_json = EXCLUDED.record_json,
updated_at_ms = EXCLUDED.updated_at_ms",
)
.bind(user_id)
.bind(section)
.bind(key)
.bind(value)
.bind(chrono::Utc::now().timestamp_millis())
.execute(&mut **tx)
.await?;
Ok(())
}
/// Relayed progress register of an episode, if any.
pub(crate) async fn progress_record(
pool: &sqlx::PgPool,
user_id: i64,
episode_id: &str,
) -> Result<Option<ProgressRecord>> {
let value: Option<Value> = sqlx::query_scalar(
"SELECT record_json FROM furumusic__fed_podcast_relay
WHERE user_id = $1 AND section = $2 AND record_key = $3",
)
.bind(user_id)
.bind(SECTION_PROGRESS)
.bind(episode_id)
.fetch_optional(pool)
.await?;
Ok(value.as_ref().and_then(parse))
}
/// Adds the relayed podcast registers to `snapshot`.
///
/// The sections are bounded later, per message, with the contract budget
/// (`SyncSnapshot::bound_podcast_state_to`) and stripped for peers below v4
/// (`SyncSnapshot::for_peer`).
pub(crate) async fn fill_snapshot(
pool: &sqlx::PgPool,
user_id: i64,
snapshot: &mut SyncSnapshot,
) -> Result<()> {
let rows = sqlx::query(
"SELECT section, record_json FROM furumusic__fed_podcast_relay
WHERE user_id = $1 AND section <> $2
ORDER BY section, record_key",
)
.bind(user_id)
.bind(SECTION_ALIASES)
.fetch_all(pool)
.await?;
for row in rows {
let section: String = row.get("section");
let value: Value = row.get("record_json");
fill_section(snapshot, &section, &value);
}
Ok(())
}
fn fill_section(snapshot: &mut SyncSnapshot, section: &str, value: &Value) {
match section {
SECTION_SUBSCRIPTION => snapshot.podcast_subscriptions.extend(parse(value)),
SECTION_SHARE => snapshot.podcast_shares.extend(parse(value)),
SECTION_PROGRESS => snapshot.podcast_progress.extend(parse(value)),
SECTION_SESSION => snapshot.podcast_listen_sessions.extend(parse(value)),
_ => {}
}
}
#[cfg(test)]
mod tests {
use super::*;
use music_dht::device_sync::{SyncOpPayload, SyncOpWire};
use music_dht::podcast::{EpisodeId, PodcastMeta, ProgressStatus};
use std::collections::BTreeMap;
fn feed(path: &str) -> FeedUrl {
FeedUrl::parse(&format!("https://podcasts.example/{path}")).unwrap()
}
fn meta() -> PodcastMeta {
serde_json::from_value(serde_json::json!({
"feed_url": feed("feed.xml").as_str(),
"title": "Example Cast",
"description": "Long channel description",
}))
.unwrap()
}
fn podcast() -> PodcastId {
PodcastId::from_feed_url(&feed("feed.xml"))
}
fn op(seq: i64, hlc_ms: i64, payload: SyncOpPayload) -> SyncOpWire {
SyncOpWire {
op_id: format!("tui_a:{seq}"),
origin_device_id: "tui_a".into(),
seq,
hlc_ms,
payload,
}
}
fn progress(seq: i64, generation: u64, hlc_ms: i64, position_ms: i64) -> SyncOpWire {
let podcast_id = podcast();
op(
seq,
hlc_ms,
SyncOpPayload::PodcastProgressSet {
episode_id: EpisodeId::from_guid(&podcast_id, "ep-1").unwrap(),
podcast_id,
position_ms,
status: ProgressStatus::InProgress,
generation,
session_id: format!("s{generation}"),
episode: None,
},
)
}
/// Applies records to an in-memory table with the production plan.
fn apply(state: &mut BTreeMap<DocKey, Value>, records: &[RelayRecord]) {
for record in records {
for (key, value) in plan_merge(state, record) {
match value {
Some(value) => state.insert(key, value),
None => state.remove(&key),
};
}
}
}
fn snapshot_of(state: &BTreeMap<DocKey, Value>) -> SyncSnapshot {
let mut snapshot = SyncSnapshot::default();
for ((section, _), value) in state {
fill_section(&mut snapshot, section, value);
}
snapshot
}
#[test]
fn progress_registers_follow_the_contract_in_any_order() {
// A late checkpoint of an older generation never wins, whatever its clock.
let ops = [
progress(1, 3, 9_000, 600_000),
progress(2, 4, 1_000, 10_000),
];
for order in [[0, 1], [1, 0]] {
let mut state = BTreeMap::new();
for index in order {
apply(&mut state, &[RelayRecord::from_op(&ops[index]).unwrap()]);
}
let snapshot = snapshot_of(&state);
assert_eq!(snapshot.podcast_progress.len(), 1);
assert_eq!(snapshot.podcast_progress[0].position_ms, 10_000);
assert_eq!(snapshot.podcast_progress[0].generation, 4);
}
}
#[test]
fn snapshot_sections_survive_the_relay() {
let subscribe = op(
1,
10,
SyncOpPayload::PodcastSubscriptionSet {
podcast_id: podcast(),
subscribed: true,
podcast: meta(),
feed_aliases: vec![],
generation: 1,
},
);
let share = op(
2,
11,
SyncOpPayload::PodcastShareSet {
podcast_id: podcast(),
shared: false,
generation: 1,
},
);
let mut source = BTreeMap::new();
for op in [&subscribe, &share, &progress(3, 2, 12, 5_000)] {
op.validate_podcast().unwrap();
apply(&mut source, &[RelayRecord::from_op(op).unwrap()]);
}
let mut sent = snapshot_of(&source);
sent.bound_podcast_state();
// A second relay that only saw the snapshot re-emits the same state.
let mut relay = BTreeMap::new();
apply(&mut relay, &RelayRecord::from_snapshot(&sent));
let mut relayed = snapshot_of(&relay);
relayed.bound_podcast_state();
assert_eq!(relayed, sent);
assert!(!relayed.podcast_shares[0].shared);
assert!(relayed.podcast_subscriptions[0].subscribed);
// Peers below v4 never receive the sections.
assert!(!relayed.for_peer(3).has_podcast_state());
assert!(relayed.for_peer(4).has_podcast_state());
}
#[test]
fn aliases_learned_before_the_subscription_are_merged_into_it() {
let aliases = op(
1,
10,
SyncOpPayload::PodcastFeedAliasesAdded {
podcast_id: podcast(),
feed_aliases: vec![feed("moved.xml")],
},
);
let subscribe = op(
2,
11,
SyncOpPayload::PodcastSubscriptionSet {
podcast_id: podcast(),
subscribed: true,
podcast: meta(),
feed_aliases: vec![],
generation: 1,
},
);
let mut state = BTreeMap::new();
apply(&mut state, &[RelayRecord::from_op(&aliases).unwrap()]);
apply(&mut state, &[RelayRecord::from_op(&subscribe).unwrap()]);
let snapshot = snapshot_of(&state);
assert_eq!(
snapshot.podcast_subscriptions[0].feed_urls(),
vec![feed("feed.xml"), feed("moved.xml")]
);
assert!(!state.keys().any(|(section, _)| *section == SECTION_ALIASES));
}
#[test]
fn oversized_snapshot_sections_are_ignored() {
let mut snapshot = SyncSnapshot::default();
let record = RelayRecord::from_op(&progress(1, 1, 1, 1)).unwrap();
let RelayRecord::Progress(record) = record else {
unreachable!()
};
snapshot.podcast_progress = vec![record; music_dht::podcast::MAX_SNAPSHOT_PROGRESS + 1];
assert!(RelayRecord::from_snapshot(&snapshot).is_empty());
snapshot
.podcast_progress
.truncate(music_dht::podcast::MAX_SNAPSHOT_PROGRESS);
assert_eq!(
RelayRecord::from_snapshot(&snapshot).len(),
music_dht::podcast::MAX_SNAPSHOT_PROGRESS
);
}
}
+3 -1
View File
@@ -305,7 +305,7 @@ translations! {
player_likes_count: "likes" , "лайков";
player_likes_playlist: "Likes" , "Лайки";
player_listened: "listened" , "прослушано";
player_search_placeholder: "Search artists, releases, tracks, podcasts..." , "Поиск артистов, релизов, треков, подкастов...";
player_search_placeholder: "Search artists, releases, tracks..." , "Поиск артистов, релизов, треков...";
player_search_similar_to: "Search similar to:" , "Поиск похожих на:";
player_find_similar: "Find similar tracks" , "Найти похожие треки";
player_similarity_failed: "Similarity search failed" , "Не удалось найти похожие треки";
@@ -382,6 +382,8 @@ translations! {
player_clear: "Clear" , "Очистить";
player_remove: "Remove" , "Удалить";
player_queue_empty: "Queue is empty" , "Очередь пуста";
player_queue_podcast_unplayable: "Podcast · not playable in the web player yet", "Подкаст · пока не воспроизводится в веб-плеере";
player_queue_private_item: "Private item · hidden by its owner", "Приватный элемент · скрыт владельцем";
player_shuffle: "Shuffle" , "Перемешать";
player_repeat: "Repeat" , "Повтор";
player_volume: "Volume" , "Громкость";
+24 -2
View File
@@ -20,6 +20,7 @@ struct PlaybackStateRow {
current_track_id: Option<i64>,
position_ms: i32,
queue_json: String,
queue_items_json: Option<serde_json::Value>,
queue_position: i32,
}
@@ -738,7 +739,7 @@ async fn cleanup_playback_states(
) -> anyhow::Result<()> {
let deleted: HashSet<i64> = track_ids.iter().copied().collect();
let states: Vec<PlaybackStateRow> = sqlx::query_as(
"SELECT id, current_track_id, position_ms, queue_json, queue_position FROM furumusic__playback_state FOR UPDATE",
"SELECT id, current_track_id, position_ms, queue_json, queue_items_json, queue_position FROM furumusic__playback_state FOR UPDATE",
)
.fetch_all(&mut **transaction)
.await?;
@@ -746,6 +747,14 @@ async fn cleanup_playback_states(
for state in states {
let mut queue: Vec<i64> = serde_json::from_str(&state.queue_json).unwrap_or_default();
let original_queue = queue.clone();
let mut typed = crate::player::queue_items::StoredQueue::from_columns(
state.queue_items_json.as_ref(),
&crate::player::queue_items::LegacyColumns {
queue: original_queue.clone(),
current_track_id: state.current_track_id,
queue_position: state.queue_position,
},
);
queue.retain(|track_id| !deleted.contains(track_id));
let current_track_id = state.current_track_id.filter(|id| !deleted.contains(id));
if queue == original_queue && current_track_id == state.current_track_id {
@@ -763,16 +772,28 @@ async fn cleanup_playback_states(
.clamp(0, i32::try_from(queue.len() - 1).unwrap_or(i32::MAX))
}
});
if let Some(typed) = &mut typed {
typed.retain_library(
|track_id| !deleted.contains(&track_id),
crate::player::queue_items::LegacyColumns {
queue: queue.clone(),
current_track_id,
queue_position,
},
);
}
let position_ms = if current_track_id.is_some() {
state.position_ms
} else {
0
};
let queue_json = serde_json::to_string(&queue)?;
// The typed queue keeps its other items; a stale one is cleared.
let queue_items_json = typed.map(serde_json::to_value).transpose()?;
sqlx::query(
r#"UPDATE furumusic__playback_state
SET current_track_id = $2, position_ms = $3,
queue_json = $4, queue_position = $5
queue_json = $4, queue_position = $5, queue_items_json = $6
WHERE id = $1"#,
)
.bind(state.id)
@@ -780,6 +801,7 @@ async fn cleanup_playback_states(
.bind(position_ms)
.bind(queue_json)
.bind(queue_position)
.bind(queue_items_json)
.execute(&mut **transaction)
.await?;
}
-6
View File
@@ -15,7 +15,6 @@ mod metrics;
mod music;
mod oidc;
mod player;
mod podcasts;
mod scheduler;
mod similarity;
mod torrents;
@@ -64,7 +63,6 @@ fn build_registry() -> Arc<JobRegistry> {
registry.register(jobs::metadata_backfill::MetadataBackfillJob);
registry.register(jobs::lastfm_popularity::LastfmPopularityJob);
registry.register(jobs::lastfm_scrobble::LastfmScrobbleJob);
registry.register(podcasts::PodcastRefreshJob);
Arc::new(registry)
}
@@ -581,10 +579,6 @@ impl Project for FuruProject {
"/admin",
);
apps.register_with_views(api::ApiApp, "/api");
apps.register_with_views(
podcasts::PodcastApp::new(Arc::clone(&self.app_config)),
"/api/podcasts",
);
apps.register_with_views(
player::PlayerApp::new(
Arc::clone(&self.app_config),
+91 -36
View File
@@ -2838,53 +2838,108 @@ 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 create_podcasts(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
for statement in include_str!("../podcasts/schema.sql").split(';') {
if !statement.trim().is_empty() {
ctx.db.raw(statement).await?;
}
}
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(())
}
#[derive(Debug, Copy, Clone)]
pub struct M0054CreatePodcasts;
impl migrations::Migration for M0054CreatePodcasts {
const APP_NAME: &'static str = "furumusic";
const MIGRATION_NAME: &'static str = "m_0054_create_podcasts";
const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
migrations::MigrationDependency::migration(
"furumusic",
"m_0052_add_import_playlist_destinations",
),
migrations::MigrationDependency::migration(
"furumusic",
"m_0053_local_approval_and_public_shares",
),
];
const OPERATIONS: &'static [Operation] = &[Operation::custom(create_podcasts).build()];
}
#[cot::db::migrations::migration_op]
async fn create_podcast_sync(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
for statement in include_str!("../podcasts/sync_schema.sql").split(';') {
if !statement.trim().is_empty() {
ctx.db.raw(statement).await?;
}
}
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 M0055PodcastSyncAndUnicodeSearch;
impl migrations::Migration for M0055PodcastSyncAndUnicodeSearch {
pub struct M0054AddTypedPlaybackQueue;
impl migrations::Migration for M0054AddTypedPlaybackQueue {
const APP_NAME: &'static str = "furumusic";
const MIGRATION_NAME: &'static str = "m_0055_podcast_sync_unicode_search";
const MIGRATION_NAME: &'static str = "m_0054_add_typed_playback_queue";
const DEPENDENCIES: &'static [migrations::MigrationDependency] =
&[migrations::MigrationDependency::migration(
"furumusic",
"m_0054_create_podcasts",
"m_0052_add_import_playlist_destinations",
)];
const OPERATIONS: &'static [Operation] = &[Operation::custom(create_podcast_sync).build()];
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] = &[
@@ -2930,7 +2985,7 @@ pub mod db_migrations {
&M0050CreateMetadataFixHistory,
&M0051AddListenStatisticsIndexes,
&M0052AddImportPlaylistDestinations,
&M0054CreatePodcasts,
&M0055PodcastSyncAndUnicodeSearch,
&M0054AddTypedPlaybackQueue,
&M0055CreateFedPodcastRelay,
];
}
+15 -1
View File
@@ -147,6 +147,17 @@ pub(super) struct PlaybackStateDto {
pub(super) shuffle: bool,
pub(super) repeat_mode: String,
pub(super) volume: f64,
/// Typed queue (podcast episodes and other non-library items included).
///
/// Requests send `{"kind": "library", "track_id"}` and
/// `{"kind": "external", "track": <device-sync PlaybackTrack>}` items;
/// responses return external items as browser track JSON. Clients that
/// omit it keep using `queue`, which is always written.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(super) queue_items: Option<serde_json::Value>,
/// Index of the current item in `queue_items`.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub(super) queue_items_position: Option<usize>,
}
#[derive(Debug, Deserialize, JsonSchema)]
@@ -263,6 +274,10 @@ pub(super) struct PlayerDevicePlaybackStateDto {
pub(super) volume: f64,
#[serde(default)]
pub(super) updated_at_ms: i64,
/// The browser does not know the position of its current item, a podcast
/// episode it cannot play (`queue_items::POSITION_UNKNOWN_KEY`).
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub(super) position_unknown: bool,
}
#[derive(Debug, Serialize, JsonSchema)]
@@ -332,7 +347,6 @@ pub(super) struct ShareDetail {
#[derive(Debug, Serialize, JsonSchema)]
pub(super) struct SearchResults {
pub(super) podcasts: Vec<serde_json::Value>,
pub(super) artists: Vec<ArtistCard>,
pub(super) releases: Vec<ReleaseCard>,
pub(super) tracks: Vec<TrackItem>,
+496 -34
View File
@@ -29,6 +29,7 @@ use crate::youtube::{YouTubePreviewRequest, YouTubeService, YouTubeStartRequest}
mod dto;
mod helpers;
mod queries;
pub(crate) mod queue_items;
mod rows;
mod sharing;
@@ -606,7 +607,7 @@ impl PlayerDeviceHub {
target_device_id: Option<&str>,
jam_id: Option<&str>,
command: &str,
payload: serde_json::Value,
mut payload: serde_json::Value,
) -> Result<(), &'static str> {
let now = current_millis();
let mut state = self.state.lock().expect("player device hub lock");
@@ -621,6 +622,15 @@ impl PlayerDeviceHub {
let target_id = self
.jam_target_device_id_locked(&state, jam)
.ok_or("jam playback device is offline")?;
if user_id != jam.host_user_id {
let host_tracks = state
.playback_state_by_user
.get(&jam.host_user_id)
.map(|playback| playback.tracks.clone())
.unwrap_or_default();
restore_jam_command_payload(command, &mut payload, &host_tracks)?;
stamp_jam_participant_command(&mut payload);
}
(jam.host_user_id, target_id)
} else {
let target_id = match target_device_id {
@@ -1042,22 +1052,17 @@ impl PlayerDeviceHub {
})
})
.unwrap_or(user_id);
state
let playback = state
.playback_state_by_user
.get(&playback_user_id)
.cloned()
.map(|playback_state| {
let mut playback_state = playback_state_at(playback_state, now);
if playback_user_id != user_id {
for track in &mut playback_state.tracks {
redact_podcast_track(track);
}
if let Some(track) = &mut playback_state.track {
redact_podcast_track(track);
}
}
playback_state
})
.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(
@@ -1161,16 +1166,6 @@ fn current_millis() -> i64 {
chrono::Utc::now().timestamp_millis()
}
fn redact_podcast_track(track: &mut serde_json::Value) {
if track.get("podcast_source").is_none()
&& track.get("podcast").and_then(serde_json::Value::as_bool) != Some(true)
{
return;
}
let id = track.get("id").cloned().unwrap_or(serde_json::json!(0));
*track = serde_json::json!({"id":id,"title":"Private item","artists":[],"featured_artists":[],"release_id":0,"release_title":"","cover_url":null,"stream_url":"","duration_seconds":0,"unavailable":true,"podcast_source":{"kind":"private"}});
}
fn fed_virtual_device_id(device_id: &str) -> String {
format!("{FED_DEVICE_PREFIX}{device_id}")
}
@@ -1478,6 +1473,7 @@ mod device_tests {
repeat_mode: "off".to_string(),
volume: 0.7,
updated_at_ms: current_millis(),
position_unknown: false,
},
);
}
@@ -1667,6 +1663,246 @@ pub struct PlayerPageTemplate {
pub youtube_downloads_enabled: bool,
}
#[cfg(test)]
mod queue_persistence_tests {
use super::*;
use music_dht::device_sync::PlaybackTrack;
fn offline_pool() -> sqlx::PgPool {
sqlx::postgres::PgPoolOptions::new()
.connect_lazy("postgres://offline@127.0.0.1:1/offline")
.unwrap()
}
fn request(queue_items: serde_json::Value, position: usize) -> PlaybackStateDto {
PlaybackStateDto {
current_track_id: Some(3),
position_ms: 1_000,
queue: vec![3, 4],
queue_position: 1,
shuffle: false,
repeat_mode: "off".into(),
volume: 0.5,
queue_items: Some(queue_items),
queue_items_position: Some(position),
}
}
#[tokio::test]
async fn podcast_items_survive_persistence_and_reload() {
let episode = PlaybackTrack::podcast_episode(queue_items::test_episode());
let browser_track = queue_items::external_track_json(&episode, 1, None);
// The browser sends `_queueItemsPayload(queue.tracks)`.
let dto = request(
serde_json::json!([
{"kind": "library", "track_id": 3},
{"kind": "external", "track": browser_track["wire_track"]},
{"kind": "library", "track_id": 4},
]),
1,
);
let stored = stored_queue_from_request(&dto).unwrap();
// Written to queue_items_json and read back with the legacy ids.
let column = serde_json::to_value(&stored).unwrap();
let row = queue_items::LegacyColumns {
queue: dto.queue.clone(),
current_track_id: dto.current_track_id,
queue_position: dto.queue_position,
};
let loaded = queue_items::StoredQueue::from_columns(Some(&column), &row).unwrap();
assert_eq!(loaded, stored);
assert_eq!(loaded.position, 1);
let items = browser_queue_items(&offline_pool(), &loaded).await.unwrap();
assert_eq!(
items[0],
serde_json::json!({"kind": "library", "track_id": 3})
);
assert_eq!(items[1]["kind"], "external");
assert_eq!(items[1]["track"]["source"]["kind"], "podcast_episode");
assert_eq!(
queue_items::wire_track_from_browser_json(&items[1]["track"]),
Some(episode)
);
}
#[test]
fn malformed_typed_queues_keep_the_legacy_ids_only() {
let dto = request(
serde_json::json!([{"kind": "external", "track": {"id": "x"}}]),
0,
);
assert!(stored_queue_from_request(&dto).is_none());
let legacy_only = PlaybackStateDto {
queue_items: None,
..request(serde_json::json!([]), 0)
};
assert!(stored_queue_from_request(&legacy_only).is_none());
// Older clients do not send the new fields.
let old: PlaybackStateDto = serde_json::from_value(serde_json::json!({
"current_track_id": 3, "position_ms": 0, "queue": [3], "queue_position": 0,
"shuffle": false, "repeat_mode": "off", "volume": 0.7,
}))
.unwrap();
assert!(old.queue_items.is_none());
assert!(!serde_json::to_string(&old).unwrap().contains("queue_items"));
}
}
#[cfg(test)]
mod jam_command_tests {
use super::*;
use music_dht::device_sync::{PRIVATE_ITEM_TITLE, PlaybackTrack};
fn library(id: i64) -> serde_json::Value {
serde_json::json!({"id": id, "title": format!("Song {id}"), "duration_seconds": 100.0})
}
fn host_tracks() -> Vec<serde_json::Value> {
let episode = PlaybackTrack::podcast_episode(queue_items::test_episode());
vec![
library(1),
queue_items::external_track_json(&episode, 1, None),
library(2),
]
}
fn check(command: &str, payload: serde_json::Value) -> Result<(), &'static str> {
let mut payload = payload;
restore_jam_command_payload(command, &mut payload, &host_tracks())
}
#[test]
fn participants_cannot_remove_or_clear_private_items() {
assert!(check("queue_remove", serde_json::json!({"index": 1})).is_err());
assert!(check("queue_clear", serde_json::json!({})).is_err());
// Music can still be removed, and private items moved.
assert!(check("queue_remove", serde_json::json!({"index": 0})).is_ok());
assert!(check("queue_remove", serde_json::json!({"index": 2})).is_ok());
assert!(
check(
"queue_move",
serde_json::json!({"from_index": 1, "to_index": 0})
)
.is_ok()
);
// The host runs `Number(index)`: other spellings of an index are refused.
for index in [
serde_json::json!("1"),
serde_json::json!(1.0),
serde_json::json!(-1),
] {
assert!(check("queue_remove", serde_json::json!({"index": index})).is_err());
}
assert!(check("queue_remove", serde_json::json!({})).is_err());
// Without private items the host queue can be cleared as before.
let mut payload = serde_json::json!({});
assert!(restore_jam_command_payload("queue_clear", &mut payload, &[library(1)]).is_ok());
}
#[test]
fn participant_commands_reach_the_host_stamped() {
let hub = PlayerDeviceHub::default();
hub.heartbeat(1, "host", None, None, None);
let jam = hub
.create_jam(1, "Host", "host", vec![(2, "Guest".to_string())])
.unwrap();
let jam_id = jam.jams[0].id.clone();
hub.heartbeat(2, "guest", None, None, None);
hub.join_jam(2, "Guest", "guest", &jam_id).unwrap();
let tracks = host_tracks();
hub.heartbeat(
1,
"host",
None,
Some(&jam_id),
Some(PlayerDevicePlaybackStateDto {
track: Some(tracks[0].clone()),
tracks,
index: 0,
position_seconds: 0.0,
duration_seconds: 100.0,
paused: false,
shuffle: false,
repeat_mode: "off".into(),
volume: 0.5,
updated_at_ms: 0,
position_unknown: false,
}),
);
// Move the episode to the end, then remove index 2: the cached host
// state still has music there, so only the host can refuse it.
for (command, payload) in [
(
"queue_move",
serde_json::json!({"from_index": 1, "to_index": 2}),
),
("queue_remove", serde_json::json!({"index": 2})),
("pause", serde_json::Value::Null),
] {
hub.enqueue_command(2, None, Some(&jam_id), command, payload)
.unwrap();
}
hub.enqueue_command(
1,
None,
Some(&jam_id),
"queue_remove",
serde_json::json!({"index": 0}),
)
.unwrap();
let commands = hub.poll(1, "host", None, Some(&jam_id), None).commands;
let stamped: Vec<bool> = commands
.iter()
.map(|command| command.payload[JAM_PARTICIPANT_KEY] == true)
.collect();
assert_eq!(stamped, [true, true, true, false]);
assert_eq!(commands[1].payload["index"], 2);
}
#[test]
fn redacted_current_episode_has_no_duration() {
let tracks = host_tracks();
let playback = PlayerDevicePlaybackStateDto {
track: Some(tracks[1].clone()),
tracks: tracks.clone(),
index: 1,
position_seconds: 1200.0,
duration_seconds: 1800.0,
paused: false,
shuffle: false,
repeat_mode: "off".into(),
volume: 0.5,
updated_at_ms: 0,
position_unknown: false,
};
let redacted = redact_playback_state_for_jam(playback.clone());
assert_eq!(redacted.duration_seconds, 0.0);
assert_eq!(
redacted.track.as_ref().unwrap()["title"],
PRIVATE_ITEM_TITLE
);
assert_eq!(redacted.position_seconds, 1200.0);
let leaked = serde_json::to_string(&redacted).unwrap();
assert!(!leaked.contains("1800") && !leaked.contains("Episode"));
// A music track keeps its duration.
let music = redact_playback_state_for_jam(PlayerDevicePlaybackStateDto {
track: Some(tracks[0].clone()),
index: 0,
duration_seconds: 100.0,
..playback.clone()
});
assert_eq!(music.duration_seconds, 100.0);
// Without `track` the current item is taken from `tracks[index]`.
let untracked = redact_playback_state_for_jam(PlayerDevicePlaybackStateDto {
track: None,
..playback
});
assert_eq!(untracked.duration_seconds, 0.0);
}
}
#[cfg(test)]
mod page_template_tests {
use super::*;
@@ -5488,7 +5724,7 @@ fn hex_value(byte: u8) -> Option<u8> {
}
}
pub(crate) fn parse_range(header: &str, file_size: u64) -> Option<(u64, u64)> {
fn parse_range(header: &str, file_size: u64) -> Option<(u64, u64)> {
if file_size == 0 {
return None;
}
@@ -5776,6 +6012,16 @@ async fn devices_select_handler(
.and_then(normalize_device_id)
.unwrap_or_else(|| target_device_id.clone());
let previous_active_id = hub.active_device_id_for_commands(user.id);
// Refuse a handoff the target cannot receive before ownership moves.
if let Some(fed_device_id) = fed_device_id_from_virtual(&target_device_id)
&& previous_active_id.as_deref() != Some(target_device_id.as_str())
&& let Some(state) = hub.playback_state_json_for_commands(user.id)
&& let Err(err) = crate::federation::handle()
.fed_device_web_transfer_check(user.id, fed_device_id, state)
.await
{
return Ok(json_error(StatusCode::CONFLICT, &format!("{err}")));
}
let Some(response) = hub.select(user.id, &current_device_id, &target_device_id) else {
return Ok(json_error(
@@ -6013,6 +6259,158 @@ async fn fed_devices_sync_handler(
}
}
/// Host playback state as shown to Jam participants
/// (`music_dht::device_sync::redact_for_jam` over the browser queue).
fn redact_playback_state_for_jam(
mut playback: PlayerDevicePlaybackStateDto,
) -> PlayerDevicePlaybackStateDto {
let index = usize::try_from(playback.index).unwrap_or(0);
let current_is_private = playback
.track
.as_ref()
.or_else(|| playback.tracks.get(index))
.is_some_and(queue_items::browser_track_requires_podcast_support);
playback.tracks = queue_items::redact_tracks_for_jam(&playback.tracks);
if current_is_private {
// Placeholders carry no duration; the host's position is kept like
// `redact_for_jam` keeps `position_secs`.
playback.duration_seconds = 0.0;
}
if playback
.track
.as_ref()
.is_some_and(queue_items::browser_track_requires_podcast_support)
{
playback.track = playback.tracks.get(index).cloned().or_else(|| {
Some(
queue_items::redact_tracks_for_jam(std::slice::from_ref(playback.track.as_ref()?))
[0]
.clone(),
)
});
}
playback
}
/// Applies the Jam privacy rules to a participant command.
///
/// Participants cannot add podcast episodes. A full queue they send (play or
/// transfer) gets the host's private items back in place of the
/// placeholders; queues that drop, duplicate or inject private items are
/// rejected. Participants cannot remove a private item, nor clear a queue
/// that holds one; they may still move it (`queue_move`).
fn restore_jam_command_payload(
command: &str,
payload: &mut serde_json::Value,
host_tracks: &[serde_json::Value],
) -> Result<(), &'static str> {
const REJECTED: &str = "podcast episodes are private and cannot be changed in a jam";
let tracks: Vec<serde_json::Value> = payload
.get("tracks")
.and_then(serde_json::Value::as_array)
.cloned()
.unwrap_or_default();
let current = payload
.get("track")
.filter(|track| !track.is_null())
.cloned();
match command {
"queue_add_end" | "queue_add_next" => {
if tracks
.iter()
.any(queue_items::browser_track_requires_podcast_support)
{
return Err(REJECTED);
}
}
"play_track" | "play_from_index" | "transfer_state" => {
if !queue_items::jam_tracks_allowed(&tracks)
|| current.as_ref().is_some_and(|track| {
!queue_items::jam_tracks_allowed(std::slice::from_ref(track))
})
{
return Err(REJECTED);
}
if tracks.is_empty() {
if current
.as_ref()
.is_some_and(queue_items::browser_track_requires_podcast_support)
{
return Err(REJECTED);
}
return Ok(());
}
let restored = queue_items::restore_jam_tracks(host_tracks, &tracks).ok_or(REJECTED)?;
if let Some(object) = payload.as_object_mut() {
if current
.as_ref()
.is_some_and(queue_items::browser_track_requires_podcast_support)
{
let index = object
.get("index")
.and_then(serde_json::Value::as_u64)
.unwrap_or(0) as usize;
let track = restored.get(index).cloned().ok_or(REJECTED)?;
object.insert("track".to_string(), track);
}
object.insert("tracks".to_string(), serde_json::Value::Array(restored));
}
}
"queue_remove" => {
// The participant view has the host's length and order, so the
// index names the same item on the host.
let index = payload
.get("index")
.and_then(serde_json::Value::as_u64)
.and_then(|index| usize::try_from(index).ok());
let removes_private = match index {
Some(index) => host_tracks
.get(index)
.is_some_and(queue_items::browser_track_requires_podcast_support),
// The host browser runs `Number(index)`, so "1" or 1.0 would
// still name an item: only plain indexes pass a private queue.
None => host_tracks
.iter()
.any(queue_items::browser_track_requires_podcast_support),
};
if removes_private {
return Err(REJECTED);
}
}
"queue_clear"
if host_tracks
.iter()
.any(queue_items::browser_track_requires_podcast_support) =>
{
return Err(REJECTED);
}
_ => {}
}
Ok(())
}
/// Marks a Jam participant command for the host browser.
///
/// `restore_jam_command_payload` checks the command against the host state of
/// the host's last report. The host browser runs its pending commands in one
/// batch, so an earlier command (a move, an insert) can make a checked index
/// name a private item there. The host browser applies the same rules to its
/// own queue for stamped commands (`_jamParticipantCommandAllowed`).
fn stamp_jam_participant_command(payload: &mut serde_json::Value) {
if !payload.is_object() {
*payload = serde_json::json!({});
}
if let Some(object) = payload.as_object_mut() {
object.insert(
JAM_PARTICIPANT_KEY.to_string(),
serde_json::Value::Bool(true),
);
}
}
/// Command payload key set by the server on Jam participant commands.
const JAM_PARTICIPANT_KEY: &str = "jam_participant";
fn stamp_jam_queue_tracks(payload: &mut serde_json::Value, user_id: i64, user_name: &str) {
let Some(tracks) = payload
.get_mut("tracks")
@@ -6341,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)
@@ -6352,6 +6750,26 @@ async fn get_state_handler(
let dto = match state {
Some(s) => {
let queue: Vec<i64> = serde_json::from_str(&s.queue_json).unwrap_or_default();
// Prefer the typed queue while it matches the legacy columns.
let typed = queue_items::StoredQueue::from_columns(
s.queue_items_json.as_ref(),
&queue_items::LegacyColumns {
queue: queue.clone(),
current_track_id: s.current_track_id,
queue_position: s.queue_position,
},
);
let (queue_items, queue_items_position) = match typed {
Some(stored) => (
Some(
browser_queue_items(pool, &stored)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?,
),
Some(stored.position),
),
None => (None, None),
};
PlaybackStateDto {
current_track_id: s.current_track_id,
position_ms: s.position_ms,
@@ -6360,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 {
@@ -6370,12 +6790,51 @@ async fn get_state_handler(
shuffle: false,
repeat_mode: "off".to_string(),
volume: 0.7,
queue_items: None,
queue_items_position: None,
},
};
Json(dto).into_response()
}
/// Typed queue items for the browser: library ids to load, external items
/// as browser track JSON with their verbatim wire item.
async fn browser_queue_items(
pool: &sqlx::PgPool,
stored: &queue_items::StoredQueue,
) -> anyhow::Result<serde_json::Value> {
let mut items = Vec::with_capacity(stored.items.len());
for (index, item) in stored.items.iter().enumerate() {
items.push(match item {
queue_items::StoredQueueItem::Library { track_id } => {
serde_json::json!({"kind": "library", "track_id": track_id})
}
queue_items::StoredQueueItem::External { track } => serde_json::json!({
"kind": "external",
"track": crate::federation::devices::resolve_playback_track(pool, track, index).await?,
}),
});
}
Ok(serde_json::Value::Array(items))
}
/// Typed queue to persist from a state request; `None` keeps only the legacy
/// ids (older clients, malformed or oversized queues).
fn stored_queue_from_request(dto: &PlaybackStateDto) -> Option<queue_items::StoredQueue> {
let items: Vec<queue_items::StoredQueueItem> =
serde_json::from_value(dto.queue_items.clone()?).ok()?;
queue_items::StoredQueue::new(
items,
dto.queue_items_position.unwrap_or(0),
queue_items::LegacyColumns {
queue: dto.queue.clone(),
current_track_id: dto.current_track_id,
queue_position: dto.queue_position,
},
)
}
// ---------------------------------------------------------------------------
// PUT /api/player/state
// ---------------------------------------------------------------------------
@@ -6393,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)
@@ -6412,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()))?;
@@ -6678,14 +7144,13 @@ async fn search_handler(
pool: &sqlx::PgPool,
query: cot::request::extractors::UrlQuery<SearchQuery>,
) -> cot::Result<cot::response::Response> {
let Some(user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
let Some(_user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
let q = query.0.q.trim().to_lowercase();
if q.is_empty() {
return Json(SearchResults {
podcasts: Vec::new(),
artists: Vec::new(),
releases: Vec::new(),
tracks: Vec::new(),
@@ -6990,9 +7455,6 @@ async fn search_handler(
.collect();
Json(SearchResults {
podcasts: crate::podcasts::search(pool, user.id, &q, limit)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?,
artists,
releases,
tracks,
+701
View File
@@ -0,0 +1,701 @@
//! Lossless queue items shared by the browser player, device sync and the
//! persisted playback state.
//!
//! The browser queue holds plain track JSON objects. Library tracks of this
//! server keep their usual shape. Every other item received from a trusted
//! device (unresolved federated music, podcast episodes, Jam private
//! placeholders) becomes an *external* item: display fields for the queue UI
//! plus the verbatim device-sync DTO under [`WIRE_TRACK_KEY`] and its explicit
//! [`PlaybackSource`] under [`SOURCE_KEY`]. Converting back to the wire uses
//! the verbatim DTO, so such items survive browser -> server -> peers ->
//! server -> browser unchanged even though this web player cannot play them.
//!
//! Gating and Jam decisions are delegated to `music_dht::device_sync`; this
//! module only maps browser JSON onto the shared DTOs.
use music_dht::device_sync::{
PRIVATE_ITEM_TITLE, PlaybackCommand, PlaybackSource, PlaybackStateWire, PlaybackTrack,
jam_command_allowed, redact_for_jam, restore_jam_private_items,
};
use serde::{Deserialize, Serialize};
use serde_json::Value;
/// Browser track key holding the verbatim [`PlaybackTrack`] of an external item.
pub(crate) const WIRE_TRACK_KEY: &str = "wire_track";
/// Browser track key holding the explicit [`PlaybackSource`] of an external item.
pub(crate) const SOURCE_KEY: &str = "source";
/// Browser playback state key: `true` when the browser does not know the
/// position of its current item. That happens when it selects a podcast
/// episode it cannot play (Next, auto-advance, a click or a play command):
/// it is never told where the episode was left, and inventing 0 would
/// restart the episode for every device. The server then takes the
/// position from the episode's progress register.
pub(crate) const POSITION_UNKNOWN_KEY: &str = "position_unknown";
/// Reason shown for federated music that is not in this library.
pub(crate) const FED_UNAVAILABLE_REASON: &str = "Not available on this web player yet";
/// Reason shown for podcast episodes, which this web player cannot play yet.
pub(crate) const PODCAST_UNAVAILABLE_REASON: &str =
"Podcast episodes cannot be played on the web player yet";
/// Reason shown for Jam placeholders of someone else's private item.
pub(crate) const PRIVATE_UNAVAILABLE_REASON: &str = "Private item of the Jam host";
/// Version of the typed queue stored in `furumusic__playback_state.queue_items_json`.
pub(crate) const STORED_QUEUE_VERSION: u16 = 1;
/// Upper bound of persisted queue items; larger queues keep only `queue_json`.
pub(crate) const MAX_STORED_QUEUE_ITEMS: usize = 10_000;
/// Browser JSON for a queue item that is not a library track of this server.
///
/// `content_id` is the normalized content id of a music item, when known.
/// The `id` is a negative placeholder that is stable for the item and its
/// queue position, so the browser can tell items apart; it never refers to a
/// library track.
pub(crate) fn external_track_json(
track: &PlaybackTrack,
index: usize,
content_id: Option<&str>,
) -> Value {
let mut json = match &track.source {
Some(PlaybackSource::PodcastEpisode(episode)) => serde_json::json!({
"id": placeholder_track_id(Some(episode.episode_id.as_str()), index),
"title": episode.episode_title,
"track_number": serde_json::Value::Null,
"disc_number": serde_json::Value::Null,
"duration_seconds": episode.duration_ms.unwrap_or(0).max(0) as f64 / 1_000.0,
"artists": artist_names_to_json(std::slice::from_ref(&episode.podcast_title)),
"featured_artists": [],
"release_id": 0,
"release_title": episode.podcast_title,
"release_year": serde_json::Value::Null,
"cover_url": serde_json::Value::Null,
"stream_url": "",
"uploader_name": "Podcast",
"audio_format": episode.mime,
"content_id": serde_json::Value::Null,
"unavailable": true,
"unavailable_reason": PODCAST_UNAVAILABLE_REASON,
}),
Some(PlaybackSource::Private) => serde_json::json!({
"id": placeholder_track_id(Some("private"), index),
"title": PRIVATE_ITEM_TITLE,
"track_number": serde_json::Value::Null,
"disc_number": serde_json::Value::Null,
"duration_seconds": 0.0,
"artists": [],
"featured_artists": [],
"release_id": 0,
"release_title": "",
"release_year": serde_json::Value::Null,
"cover_url": serde_json::Value::Null,
"stream_url": "",
"uploader_name": "",
"content_id": serde_json::Value::Null,
"unavailable": true,
"unavailable_reason": PRIVATE_UNAVAILABLE_REASON,
}),
Some(PlaybackSource::Music) | None => music_placeholder_json(track, index, content_id),
};
if let Some(object) = json.as_object_mut() {
if let Some(source) = &track.source
&& let Ok(source) = serde_json::to_value(source)
{
object.insert(SOURCE_KEY.to_string(), source);
}
if let Ok(wire) = serde_json::to_value(track) {
object.insert(WIRE_TRACK_KEY.to_string(), wire);
}
}
json
}
/// Display fields of unresolved federated music (unchanged from earlier
/// releases, which had no verbatim wire item).
fn music_placeholder_json(track: &PlaybackTrack, index: usize, content_id: Option<&str>) -> Value {
let artists = if !track.artist_names.is_empty() {
track.artist_names.clone()
} else if let Some(fed) = &track.fed {
fed.artist_names.clone()
} else {
Vec::new()
};
let featured = if !track.featured_artist_names.is_empty() {
track.featured_artist_names.clone()
} else if let Some(fed) = &track.fed {
fed.featured_artist_names.clone()
} else {
Vec::new()
};
let title = track
.fed
.as_ref()
.map(|fed| fed.title.as_str())
.filter(|title| !title.trim().is_empty())
.unwrap_or(&track.title);
let release_title = track
.fed
.as_ref()
.and_then(|fed| fed.release_title.as_deref())
.filter(|title| !title.trim().is_empty())
.unwrap_or(&track.release_title);
let content_id = content_id
.map(ToString::to_string)
.or_else(|| track.content_id.clone())
.or_else(|| track.fed.as_ref().map(|fed| fed.content_id.clone()));
serde_json::json!({
"id": placeholder_track_id(content_id.as_deref(), index),
"title": title,
"track_number": track.track_number,
"disc_number": track.disc_number,
"duration_seconds": track.duration_seconds,
"artists": artist_names_to_json(&artists),
"featured_artists": artist_names_to_json(&featured),
"release_id": 0,
"release_title": release_title,
"release_year": track.release_year,
"cover_url": serde_json::Value::Null,
"stream_url": "",
"uploader_name": "Federation",
"audio_format": track.audio_format.clone(),
"audio_bitrate": track.audio_bitrate,
"audio_sample_rate": track.audio_sample_rate,
"audio_bit_depth": track.audio_bit_depth,
"file_size_bytes": track.file_size_bytes,
"content_id": content_id,
"unavailable": true,
"unavailable_reason": FED_UNAVAILABLE_REASON,
})
}
fn artist_names_to_json(names: &[String]) -> Vec<Value> {
names
.iter()
.enumerate()
.filter(|(_, name)| !name.trim().is_empty())
.map(|(index, name)| serde_json::json!({"id": -((index as i64) + 1), "name": name}))
.collect()
}
fn placeholder_track_id(seed: Option<&str>, index: usize) -> i64 {
let mut bytes = [0u8; 8];
let hash = blake3::hash(seed.unwrap_or("").as_bytes());
bytes.copy_from_slice(&hash.as_bytes()[..8]);
let value = i64::from_le_bytes(bytes).unsigned_abs() % 9_000_000_000_000;
-((value as i64) + index as i64 + 1)
}
/// The device-sync item carried by an external browser track.
///
/// Returns the verbatim [`WIRE_TRACK_KEY`] DTO when present. Otherwise a
/// browser item that only names a podcast or private [`SOURCE_KEY`] is
/// rebuilt with the shared constructors. Library tracks (and malformed
/// items) return `None` and keep the library mapping.
pub(crate) fn wire_track_from_browser_json(track: &Value) -> Option<PlaybackTrack> {
if let Some(wire) = track.get(WIRE_TRACK_KEY).filter(|wire| wire.is_object())
&& let Ok(wire) = serde_json::from_value::<PlaybackTrack>(wire.clone())
{
return Some(wire);
}
match serde_json::from_value::<PlaybackSource>(track.get(SOURCE_KEY)?.clone()).ok()? {
PlaybackSource::PodcastEpisode(episode) => Some(PlaybackTrack::podcast_episode(*episode)),
PlaybackSource::Private => Some(PlaybackTrack::private_placeholder()),
PlaybackSource::Music => None,
}
}
/// Whether a browser item is a podcast episode or a Jam placeholder.
pub(crate) fn browser_track_requires_podcast_support(track: &Value) -> bool {
wire_track_from_browser_json(track).is_some_and(|track| track.requires_podcast_support())
}
/// Wire-shaped view of browser tracks for the shared gating and Jam helpers.
///
/// External items are their verbatim DTOs. Library tracks become minimal
/// music items: the helpers only look at item sources and positions, so
/// this conversion needs no database lookups.
pub(crate) fn shadow_wire_state(tracks: &[Value], index: usize) -> PlaybackStateWire {
PlaybackStateWire {
queue: tracks
.iter()
.map(|track| wire_track_from_browser_json(track).unwrap_or_else(|| music_stub(track)))
.collect(),
queue_pos: index,
playing: false,
paused: true,
idle_since_ms: None,
position_secs: 0.0,
volume: 0,
shuffle: false,
repeat: Default::default(),
playback_rate: None,
}
}
fn music_stub(track: &Value) -> PlaybackTrack {
PlaybackTrack {
id: track.get("id").and_then(Value::as_i64).unwrap_or(0),
title: String::new(),
track_number: None,
disc_number: None,
duration_seconds: 0.0,
artist_names: Vec::new(),
featured_artist_names: Vec::new(),
release_id: 0,
release_title: String::new(),
release_year: None,
file_path: String::new(),
content_id: None,
audio_format: None,
audio_bitrate: None,
audio_sample_rate: None,
audio_bit_depth: None,
file_size_bytes: None,
play_count: 0,
fed: None,
source: None,
}
}
/// Browser tracks as shown to Jam participants.
///
/// Uses [`redact_for_jam`]: every podcast episode (and existing placeholder)
/// becomes the opaque private placeholder; music, order and position stay.
pub(crate) fn redact_tracks_for_jam(tracks: &[Value]) -> Vec<Value> {
let redacted = redact_for_jam(shadow_wire_state(tracks, 0));
tracks
.iter()
.zip(redacted.queue.iter())
.enumerate()
.map(|(index, (original, redacted))| {
if redacted.is_private_placeholder() {
external_track_json(redacted, index, None)
} else {
original.clone()
}
})
.collect()
}
/// Maps the private placeholders of a Jam participant's full queue back to
/// the host's items ([`restore_jam_private_items`]).
///
/// Returns `None` when the participant queue contains real podcast episodes
/// or drops, duplicates or injects private items; the command is then
/// rejected.
pub(crate) fn restore_jam_tracks(host: &[Value], participant: &[Value]) -> Option<Vec<Value>> {
let host_state = shadow_wire_state(host, 0);
let restored = restore_jam_private_items(&host_state, shadow_wire_state(participant, 0))?;
let mut host_private = host
.iter()
.zip(host_state.queue.iter())
.filter(|(_, wire)| wire.requires_podcast_support())
.map(|(json, _)| json);
let participant_state = shadow_wire_state(participant, 0);
let mut out = Vec::with_capacity(participant.len());
for ((json, before), after) in participant
.iter()
.zip(participant_state.queue.iter())
.zip(restored.queue.iter())
{
if before.is_private_placeholder() {
out.push(host_private.next()?.clone());
} else {
debug_assert_eq!(before, after);
out.push(json.clone());
}
}
Some(out)
}
/// Whether tracks sent by a Jam participant may enter the host queue at all
/// ([`jam_command_allowed`]): participants cannot add podcast episodes.
pub(crate) fn jam_tracks_allowed(tracks: &[Value]) -> bool {
jam_command_allowed(&PlaybackCommand::SetState {
state: shadow_wire_state(tracks, 0),
seek: false,
})
}
/// Typed playback queue persisted next to the legacy `queue_json`.
///
/// `queue_json` (a list of library track ids) is still written for rollback
/// to older releases. `legacy_queue`, `legacy_current_track_id` and
/// `legacy_queue_position` record the legacy columns written alongside this
/// value: when they no longer match the row (an older release or a
/// legacy-only writer changed the queue or moved to another track since),
/// readers ignore the typed value and fall back to the legacy columns.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub(crate) struct StoredQueue {
/// Shape version, [`STORED_QUEUE_VERSION`].
pub(crate) version: u16,
/// Index of the current item in `items`.
#[serde(default)]
pub(crate) position: usize,
/// Queue items in order.
#[serde(default)]
pub(crate) items: Vec<StoredQueueItem>,
/// `queue_json` ids written together with this value.
#[serde(default)]
pub(crate) legacy_queue: Vec<i64>,
/// `current_track_id` written together with this value.
#[serde(default)]
pub(crate) legacy_current_track_id: Option<i64>,
/// `queue_position` written together with this value (`None`: unknown,
/// the value is not used).
#[serde(default)]
pub(crate) legacy_queue_position: Option<i32>,
}
/// Legacy queue columns of a `furumusic__playback_state` row.
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub(crate) struct LegacyColumns {
/// `queue_json`: library track ids.
pub(crate) queue: Vec<i64>,
/// `current_track_id`.
pub(crate) current_track_id: Option<i64>,
/// `queue_position`.
pub(crate) queue_position: i32,
}
/// One persisted queue item.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub(crate) enum StoredQueueItem {
/// Library track of this server.
Library {
/// Local track id.
track_id: i64,
},
/// Any other item, kept verbatim with its explicit `source`.
External {
/// Device-sync queue item.
track: Box<PlaybackTrack>,
},
}
impl StoredQueue {
/// Builds the persisted value; `None` when the queue exceeds the bound.
///
/// Jam private placeholders are dropped: they stand for the Jam host's
/// items, never for items of this user's own queue.
pub(crate) fn new(
items: Vec<StoredQueueItem>,
position: usize,
legacy: LegacyColumns,
) -> Option<Self> {
if items.len() > MAX_STORED_QUEUE_ITEMS {
return None;
}
let mut stored = Self {
version: STORED_QUEUE_VERSION,
position,
items,
legacy_queue: Vec::new(),
legacy_current_track_id: None,
legacy_queue_position: None,
};
stored.retain_items(|item| match item {
StoredQueueItem::Library { .. } => true,
StoredQueueItem::External { track } => !track.is_private_placeholder(),
});
stored.set_legacy(legacy);
Some(stored)
}
/// Reads the typed column, preferring it over the legacy columns only
/// when it has a known version and was written together with exactly
/// these legacy values.
pub(crate) fn from_columns(typed: Option<&Value>, legacy: &LegacyColumns) -> Option<Self> {
let stored = serde_json::from_value::<Self>(typed?.clone()).ok()?;
(stored.version == STORED_QUEUE_VERSION
&& stored.legacy_queue == legacy.queue
&& stored.legacy_current_track_id == legacy.current_track_id
&& stored.legacy_queue_position == Some(legacy.queue_position)
&& stored.items.len() <= MAX_STORED_QUEUE_ITEMS)
.then_some(stored)
}
/// Removes library tracks rejected by `keep` and records the new legacy
/// columns. The current position follows its item, or the item after it
/// when the current item was removed.
pub(crate) fn retain_library(&mut self, keep: impl Fn(i64) -> bool, legacy: LegacyColumns) {
self.retain_items(|item| match item {
StoredQueueItem::Library { track_id } => keep(*track_id),
StoredQueueItem::External { .. } => true,
});
self.set_legacy(legacy);
}
fn retain_items(&mut self, keep: impl Fn(&StoredQueueItem) -> bool) {
let original_position = self.position;
let mut position = self.position;
let mut index = 0;
self.items.retain(|item| {
let retained = keep(item);
if !retained && index < original_position {
position = position.saturating_sub(1);
}
index += 1;
retained
});
self.position = position.min(self.items.len().saturating_sub(1));
}
fn set_legacy(&mut self, legacy: LegacyColumns) {
self.legacy_queue = legacy.queue;
self.legacy_current_track_id = legacy.current_track_id;
self.legacy_queue_position = Some(legacy.queue_position);
}
}
/// A valid podcast episode reference for tests.
#[cfg(test)]
pub(crate) fn test_episode() -> music_dht::podcast::PodcastEpisodeRef {
use music_dht::podcast::{EpisodeId, FeedUrl, PodcastEpisodeRef, PodcastId};
let feed_url = FeedUrl::parse("https://podcasts.example/feed.xml?token=Ab").unwrap();
let podcast_id = PodcastId::from_feed_url(&feed_url);
let episode_id = EpisodeId::from_guid(&podcast_id, "episode-42").unwrap();
PodcastEpisodeRef {
podcast_id,
episode_id,
feed_url,
podcast_title: "Example Cast".into(),
episode_title: "Episode 42".into(),
audio_url: "https://cdn.example/ep42.mp3".into(),
mime: Some("audio/mpeg".into()),
duration_ms: Some(1_800_000),
published_at_ms: Some(1_700_000_000_000),
season: Some(2),
episode_number: Some(42),
image_url: None,
progress_generation: Some(7),
}
}
#[cfg(test)]
mod tests {
use super::*;
use music_dht::podcast::EpisodeId;
fn episode() -> music_dht::podcast::PodcastEpisodeRef {
test_episode()
}
fn library(id: i64) -> Value {
serde_json::json!({"id": id, "title": format!("Track {id}"), "stream_url": format!("/api/player/stream/{id}")})
}
#[test]
fn podcast_item_round_trips_through_browser_json() {
let mut wire = PlaybackTrack::podcast_episode(episode());
wire.play_count = 3;
let json = external_track_json(&wire, 4, None);
assert_eq!(json["unavailable"], true);
assert_eq!(json["unavailable_reason"], PODCAST_UNAVAILABLE_REASON);
assert_eq!(json["title"], "Episode 42");
assert_eq!(json[SOURCE_KEY]["kind"], "podcast_episode");
assert!(json["id"].as_i64().unwrap() < 0);
// The browser stores and echoes the object; the item is unchanged.
let echoed: Value = serde_json::from_str(&json.to_string()).unwrap();
assert_eq!(wire_track_from_browser_json(&echoed), Some(wire));
}
#[test]
fn private_and_unresolved_music_keep_their_wire_item() {
let private = PlaybackTrack::private_placeholder();
let json = external_track_json(&private, 0, None);
assert_eq!(json["title"], PRIVATE_ITEM_TITLE);
assert_eq!(json[SOURCE_KEY]["kind"], "private");
assert_eq!(wire_track_from_browser_json(&json), Some(private));
let mut music = PlaybackTrack::private_placeholder();
music.source = None;
music.title = "Remote song".into();
music.content_id = Some(format!("b3:{}", "a".repeat(64)));
let json = external_track_json(&music, 1, music.content_id.as_deref());
assert!(json.get(SOURCE_KEY).is_none());
assert_eq!(json["unavailable_reason"], FED_UNAVAILABLE_REASON);
assert_eq!(wire_track_from_browser_json(&json), Some(music));
}
#[test]
fn library_tracks_are_not_external() {
assert_eq!(wire_track_from_browser_json(&library(5)), None);
let mut music_source = library(6);
music_source[SOURCE_KEY] = serde_json::json!({"kind": "music"});
assert_eq!(wire_track_from_browser_json(&music_source), None);
}
#[test]
fn source_only_items_use_shared_constructors() {
let json = serde_json::json!({
"id": -1,
SOURCE_KEY: serde_json::to_value(PlaybackSource::PodcastEpisode(Box::new(episode()))).unwrap(),
});
assert_eq!(
wire_track_from_browser_json(&json),
Some(PlaybackTrack::podcast_episode(episode()))
);
// A malformed verbatim item falls back to the explicit source.
let mut tampered = json.clone();
tampered[WIRE_TRACK_KEY] = serde_json::json!({"id": "x"});
assert_eq!(
wire_track_from_browser_json(&tampered),
Some(PlaybackTrack::podcast_episode(episode()))
);
}
#[test]
fn jam_redaction_hides_episodes_and_restores_them_in_order() {
let first = external_track_json(&PlaybackTrack::podcast_episode(episode()), 1, None);
let mut other = episode();
other.episode_title = "Episode 43".into();
other.episode_id = EpisodeId::from_guid(&other.podcast_id, "episode-43").unwrap();
let second = external_track_json(&PlaybackTrack::podcast_episode(other), 3, None);
let host = vec![library(1), first.clone(), library(2), second.clone()];
let redacted = redact_tracks_for_jam(&host);
assert_eq!(redacted[0], host[0]);
assert_eq!(redacted[1]["title"], PRIVATE_ITEM_TITLE);
let leaked = serde_json::to_string(&redacted).unwrap();
assert!(!leaked.contains("Episode 4") && !leaked.contains("podcasts.example"));
assert!(!leaked.contains("cdn.example") && !leaked.contains("Example Cast"));
// The participant reorders music and moves a placeholder.
let participant = vec![
redacted[3].clone(),
library(2),
redacted[1].clone(),
library(1),
];
let restored = restore_jam_tracks(&host, &participant).unwrap();
assert_eq!(
restored,
vec![first.clone(), library(2), second, library(1)]
);
// Dropping, duplicating or injecting private items is rejected.
assert!(restore_jam_tracks(&host, &[library(1), redacted[1].clone()]).is_none());
assert!(restore_jam_tracks(&host, &[first.clone(), redacted[1].clone()]).is_none());
assert!(!jam_tracks_allowed(std::slice::from_ref(&first)));
assert!(jam_tracks_allowed(&[library(9)]));
}
fn legacy(queue: &[i64], current_track_id: Option<i64>, queue_position: i32) -> LegacyColumns {
LegacyColumns {
queue: queue.to_vec(),
current_track_id,
queue_position,
}
}
#[test]
fn stored_queue_prefers_typed_value_only_while_legacy_ids_match() {
let items = vec![
StoredQueueItem::Library { track_id: 3 },
StoredQueueItem::External {
track: Box::new(PlaybackTrack::podcast_episode(episode())),
},
StoredQueueItem::Library { track_id: 4 },
];
// The episode is current: the browser wrote its placeholder id.
let written = legacy(&[3, -11, 4], Some(-11), 1);
let stored = StoredQueue::new(items, 1, written.clone()).unwrap();
let value = serde_json::to_value(&stored).unwrap();
assert_eq!(value["version"], 1);
assert_eq!(value["items"][1]["kind"], "external");
assert_eq!(
value["items"][1]["track"]["source"]["kind"],
"podcast_episode"
);
assert_eq!(
StoredQueue::from_columns(Some(&value), &written),
Some(stored.clone())
);
// A rollback release rewrote queue_json: fall back to it.
assert_eq!(
StoredQueue::from_columns(Some(&value), &legacy(&[3, 4], Some(4), 1)),
None
);
// A rollback release kept the ids but moved to another track (Next
// or a click): the typed position is stale, fall back as well.
assert_eq!(
StoredQueue::from_columns(Some(&value), &legacy(&[3, -11, 4], Some(4), 2)),
None
);
assert_eq!(
StoredQueue::from_columns(Some(&value), &legacy(&[3, -11, 4], Some(-11), 0)),
None
);
// Values without the recorded current item are not trusted.
let mut unknown = value.clone();
unknown
.as_object_mut()
.unwrap()
.remove("legacy_queue_position");
assert_eq!(StoredQueue::from_columns(Some(&unknown), &written), None);
let mut future = value.clone();
future["version"] = serde_json::json!(2);
assert_eq!(StoredQueue::from_columns(Some(&future), &written), None);
assert_eq!(StoredQueue::from_columns(None, &written), None);
}
#[test]
fn stored_queue_never_keeps_jam_placeholders() {
let items = vec![
StoredQueueItem::Library { track_id: 3 },
StoredQueueItem::External {
track: Box::new(PlaybackTrack::private_placeholder()),
},
StoredQueueItem::External {
track: Box::new(PlaybackTrack::podcast_episode(episode())),
},
StoredQueueItem::Library { track_id: 4 },
];
let stored = StoredQueue::new(items.clone(), 3, legacy(&[3, 4], Some(4), 1)).unwrap();
assert_eq!(
stored.items,
vec![items[0].clone(), items[2].clone(), items[3].clone()]
);
assert_eq!(stored.position, 2);
// A current placeholder hands the position to the next item.
let stored = StoredQueue::new(items.clone(), 1, legacy(&[3, 4], None, 0)).unwrap();
assert_eq!(stored.position, 1);
assert_eq!(stored.items[1], items[2]);
}
#[test]
fn stored_queue_cleanup_keeps_external_items_and_position() {
let items = vec![
StoredQueueItem::Library { track_id: 3 },
StoredQueueItem::External {
track: Box::new(PlaybackTrack::podcast_episode(episode())),
},
StoredQueueItem::Library { track_id: 4 },
];
let mut stored = StoredQueue::new(items.clone(), 1, legacy(&[3, 4], None, 0)).unwrap();
stored.retain_library(|id| id != 3, legacy(&[4], None, 0));
assert_eq!(stored.items, items[1..].to_vec());
assert_eq!(stored.position, 0);
assert_eq!(stored.legacy_queue, vec![4]);
// The cleanup's new legacy columns are what readers compare with.
let value = serde_json::to_value(&stored).unwrap();
assert_eq!(
StoredQueue::from_columns(Some(&value), &legacy(&[4], None, 0)),
Some(stored)
);
let mut current_removed =
StoredQueue::new(items.clone(), 2, legacy(&[3, 4], Some(4), 1)).unwrap();
current_removed.retain_library(|id| id != 4, legacy(&[3], None, 0));
assert_eq!(current_removed.position, 1);
assert!(
StoredQueue::new(
vec![items[0].clone(); MAX_STORED_QUEUE_ITEMS + 1],
0,
LegacyColumns::default()
)
.is_none()
);
}
}
+1
View File
@@ -65,6 +65,7 @@ pub(super) struct PlaybackStateRow {
pub(super) current_track_id: Option<i64>,
pub(super) position_ms: i32,
pub(super) queue_json: String,
pub(super) queue_items_json: Option<serde_json::Value>,
pub(super) queue_position: i32,
pub(super) shuffle: bool,
pub(super) repeat_mode: String,
-515
View File
@@ -1,515 +0,0 @@
//! Server-owned podcast catalogue and cache; subscriptions and progress are personal.
pub(crate) mod sync;
mod web;
pub use web::PodcastApp;
use crate::{
config::AppConfig,
scheduler::{Job, JobContext, JobLog},
};
use anyhow::{Context, Result, bail};
use futures_util::StreamExt;
use music_dht::podcast::feed::parse_feed_with_base;
use music_dht::podcast::{
EpisodeMeta, FeedUrl, KnownEpisode, PodcastId, PodcastMeta, ShareRecord, SubscriptionRecord,
};
use music_dht::podcast_dht::{PodcastCardSpec, PodcastDht, PodcastShareState};
use serde_json::{Value, json};
use sqlx::{PgPool, Row};
use std::{net::IpAddr, path::PathBuf, time::Duration};
use tokio::io::AsyncWriteExt;
const MAX_FEED_BYTES: usize = 16 * 1024 * 1024;
const MAX_AUDIO_BYTES: u64 = 2 * 1024 * 1024 * 1024;
pub(crate) async fn search(
pool: &PgPool,
user: i64,
query: &str,
limit: i64,
) -> Result<Vec<Value>> {
let words: Vec<String> = query
.split_whitespace()
.take(20)
.map(|word| {
format!(
"%{}%",
word.replace('\\', "\\\\")
.replace('%', "\\%")
.replace('_', "\\_")
)
})
.collect();
if words.is_empty() {
return Ok(Vec::new());
}
Ok(sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'url',p.origin_url,'metadata',p.metadata,'subscribed',EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.user_id=$1 AND s.podcast_id=p.id)) FROM furumusic__podcast p WHERE EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id AND (s.user_id=$1 OR s.shared)) AND NOT EXISTS(SELECT 1 FROM unnest($2::text[]) AS term WHERE concat_ws(' ',p.metadata->>'title',p.metadata->>'description',p.metadata->>'author') COLLATE furumusic_unicode NOT ILIKE term) ORDER BY p.metadata->>'title',p.id LIMIT $3").bind(user).bind(words).bind(limit.clamp(1,100)).fetch_all(pool).await?)
}
fn public_address(ip: IpAddr) -> bool {
match ip {
IpAddr::V4(ip) => {
!(ip.is_private()
|| ip.is_loopback()
|| ip.is_link_local()
|| ip.is_unspecified()
|| ip.is_multicast()
|| ip.is_broadcast()
|| ip.octets()[0] == 0
|| ip.octets()[0] >= 240
|| (ip.octets()[0] == 100 && (64..=127).contains(&ip.octets()[1])))
}
IpAddr::V6(ip) => ip
.to_ipv4_mapped()
.map(|v| public_address(IpAddr::V4(v)))
.unwrap_or_else(|| (ip.segments()[0] & 0xe000) == 0x2000),
}
}
/// Resolve and pin public addresses on every redirect, including enclosure requests.
pub(super) async fn fetch(
url: &str,
range: Option<&str>,
validators: Option<(&str, &str)>,
) -> Result<reqwest::Response> {
let mut url = reqwest::Url::parse(FeedUrl::parse(url)?.as_str())?;
for _ in 0..8 {
let host = url.host_str().context("missing host")?;
let addresses: Vec<_> =
tokio::net::lookup_host((host, url.port_or_known_default().context("missing port")?))
.await?
.collect();
if addresses.is_empty() || addresses.iter().any(|a| !public_address(a.ip())) {
bail!("podcast sources must use public internet addresses");
}
let client = reqwest::Client::builder()
.no_proxy()
.redirect(reqwest::redirect::Policy::none())
.connect_timeout(Duration::from_secs(15))
.timeout(Duration::from_secs(600))
.user_agent(concat!("FuruMusic/", env!("CARGO_PKG_VERSION")))
.resolve_to_addrs(host, &addresses)
.build()?;
let mut request = client.get(url.clone());
if let Some(range) = range {
request = request.header("Range", range);
}
if let Some((etag, modified)) = validators {
if !etag.is_empty() {
request = request.header("If-None-Match", etag);
}
if !modified.is_empty() {
request = request.header("If-Modified-Since", modified);
}
}
let response = request
.send()
.await
.context("podcast source request failed")?;
if response.status() == reqwest::StatusCode::NOT_MODIFIED {
return Ok(response);
}
if response.status().is_redirection() {
url = url.join(
response
.headers()
.get("location")
.context("redirect without location")?
.to_str()?,
)?;
FeedUrl::parse(url.as_str())?;
continue;
}
return response
.error_for_status()
.context("podcast source returned an error");
}
bail!("too many podcast redirects")
}
async fn feed_bytes(response: reqwest::Response) -> Result<Vec<u8>> {
if response
.content_length()
.is_some_and(|len| len > MAX_FEED_BYTES as u64)
{
bail!("feed is too large");
}
let mut bytes = Vec::new();
let mut stream = response.bytes_stream();
while let Some(chunk) = stream.next().await {
let chunk = chunk?;
if bytes.len() + chunk.len() > MAX_FEED_BYTES {
bail!("feed is too large");
}
bytes.extend_from_slice(&chunk);
}
Ok(bytes)
}
pub(super) fn cache_path(config: &AppConfig, id: &str) -> PathBuf {
PathBuf::from(&config.agent_storage_dir)
.join("podcasts")
.join(blake3::hash(id.as_bytes()).to_hex().as_str())
}
pub(super) async fn subscribe(pool: &PgPool, user: i64, input: &str) -> Result<String> {
let origin = FeedUrl::from_user_input(input)?;
let existing: Option<String> =
sqlx::query_scalar("SELECT podcast_id FROM furumusic__podcast_alias WHERE url=$1")
.bind(origin.as_str())
.fetch_optional(pool)
.await?;
let id = if let Some(id) = existing {
id
} else {
let response = fetch(origin.as_str(), None, None).await?;
let final_url = FeedUrl::parse(response.url().as_str())?;
let bytes = feed_bytes(response).await?;
let feed = parse_feed_with_base(&bytes, Some(final_url.as_str()))?;
let mut tx = pool.begin().await?;
// Serialize identity resolution: two users subscribing via a redirect share one catalogue.
sqlx::query("SELECT pg_advisory_xact_lock(73829531)")
.execute(&mut *tx)
.await?;
let existing: Option<String> = sqlx::query_scalar(
"SELECT podcast_id FROM furumusic__podcast_alias WHERE url=$1 OR url=$2 LIMIT 1",
)
.bind(origin.as_str())
.bind(final_url.as_str())
.fetch_optional(&mut *tx)
.await?;
let id = existing.unwrap_or_else(|| PodcastId::from_feed_url(&origin).as_str().to_owned());
sqlx::query("INSERT INTO furumusic__podcast(id,origin_url,feed_url,metadata) VALUES($1,$2,$3,$4) ON CONFLICT(id) DO NOTHING")
.bind(&id).bind(origin.as_str()).bind(final_url.as_str()).bind(serde_json::to_value(feed.to_podcast_meta(final_url.clone()))?).execute(&mut *tx).await?;
for url in [&origin, &final_url] {
sqlx::query("INSERT INTO furumusic__podcast_alias(url,podcast_id) VALUES($1,$2) ON CONFLICT DO NOTHING").bind(url.as_str()).bind(&id).execute(&mut *tx).await?;
}
tx.commit().await?;
id
};
sqlx::query("INSERT INTO furumusic__podcast_subscription(user_id,podcast_id) VALUES($1,$2) ON CONFLICT DO NOTHING").bind(user).bind(&id).execute(pool).await?;
Ok(id)
}
pub(super) async fn refresh(pool: &PgPool, id: &str) -> Result<usize> {
let result = tokio::time::timeout(Duration::from_secs(60), refresh_inner(pool, id))
.await
.unwrap_or_else(|_| Err(anyhow::anyhow!("feed check timed out")));
if result.is_err() {
sqlx::query("UPDATE furumusic__podcast SET checked_at=now(),last_error='Feed check failed; retry later' WHERE id=$1").bind(id).execute(pool).await?;
}
result
}
async fn refresh_inner(pool: &PgPool, id: &str) -> Result<usize> {
let mut tx = pool.begin().await?;
sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1,7391))")
.bind(id)
.execute(&mut *tx)
.await?;
let row = sqlx::query("SELECT * FROM furumusic__podcast WHERE id=$1 FOR UPDATE")
.bind(id)
.fetch_one(&mut *tx)
.await?;
let url: String = row.get("feed_url");
let etag: Option<String> = row.get("etag");
let modified: Option<String> = row.get("modified");
let response = fetch(
&url,
None,
Some((
etag.as_deref().unwrap_or(""),
modified.as_deref().unwrap_or(""),
)),
)
.await?;
if response.status() == reqwest::StatusCode::NOT_MODIFIED {
sqlx::query("UPDATE furumusic__podcast SET checked_at=now(),last_error=NULL WHERE id=$1")
.bind(id)
.execute(&mut *tx)
.await?;
tx.commit().await?;
return Ok(0);
}
let final_url = FeedUrl::parse(response.url().as_str())?;
let etag = response
.headers()
.get("etag")
.and_then(|v| v.to_str().ok())
.map(str::to_owned);
let modified = response
.headers()
.get("last-modified")
.and_then(|v| v.to_str().ok())
.map(str::to_owned);
let bytes = feed_bytes(response).await?;
let feed = parse_feed_with_base(&bytes, Some(final_url.as_str()))?;
let podcast_id: PodcastId = serde_json::from_value(json!(id))?;
let stored: Vec<Value> =
sqlx::query_scalar("SELECT metadata FROM furumusic__podcast_episode WHERE podcast_id=$1")
.bind(id)
.fetch_all(&mut *tx)
.await?;
let known: Vec<_> = stored
.into_iter()
.map(serde_json::from_value::<EpisodeMeta>)
.collect::<std::result::Result<Vec<_>, _>>()?
.into_iter()
.map(|meta| KnownEpisode {
episode_id: meta.episode_id.clone(),
hints: meta.identity_hints(),
})
.collect();
let ids = feed.resolve_episode_ids(&podcast_id, &known);
let mut added = 0;
for (episode, episode_id) in feed.episodes.iter().zip(ids) {
let Some(episode_id) = episode_id else {
continue;
};
let meta = episode.to_meta(&podcast_id, episode_id.clone());
let inserted: bool = sqlx::query_scalar("INSERT INTO furumusic__podcast_episode(id,podcast_id,metadata) VALUES($1,$2,$3) ON CONFLICT(id) DO UPDATE SET metadata=EXCLUDED.metadata RETURNING (xmax=0)").bind(episode_id.as_str()).bind(id).bind(serde_json::to_value(meta)?).fetch_one(&mut *tx).await?;
added += usize::from(inserted);
sync::restore_episode_progress(&mut tx, episode_id.as_str()).await?;
}
for alias in [
Some(final_url.clone()),
feed.new_feed_url
.as_deref()
.and_then(|u| FeedUrl::parse(u).ok()),
]
.into_iter()
.flatten()
{
sqlx::query("INSERT INTO furumusic__podcast_alias(url,podcast_id) VALUES($1,$2) ON CONFLICT DO NOTHING").bind(alias.as_str()).bind(id).execute(&mut *tx).await?;
}
let next_url = feed
.new_feed_url
.as_deref()
.and_then(|u| FeedUrl::parse(u).ok())
.unwrap_or(final_url.clone());
let moved = next_url != final_url;
sqlx::query("UPDATE furumusic__podcast SET feed_url=$2,metadata=$3,etag=$4,modified=$5,checked_at=now(),last_error=NULL WHERE id=$1")
.bind(id).bind(next_url.as_str()).bind(serde_json::to_value(feed.to_podcast_meta(next_url.clone()))?).bind(if moved {None} else {etag}).bind(if moved {None} else {modified}).execute(&mut *tx).await?;
tx.commit().await?;
Ok(added)
}
pub(super) async fn download(
pool: &PgPool,
config: &AppConfig,
id: &str,
force: bool,
) -> Result<()> {
static DOWNLOADS: tokio::sync::Semaphore = tokio::sync::Semaphore::const_new(3);
let _permit = DOWNLOADS.acquire().await?;
let podcast: Option<String> =
sqlx::query_scalar("SELECT podcast_id FROM furumusic__podcast_episode WHERE id=$1")
.bind(id)
.fetch_optional(pool)
.await?;
let Some(podcast) = podcast else {
return Ok(());
};
let mut cache_guard = pool.begin().await?;
sqlx::query("SELECT pg_advisory_xact_lock_shared(hashtextextended($1,7421))")
.bind(&podcast)
.execute(&mut *cache_guard)
.await?;
let meta: Option<Value> = sqlx::query_scalar("UPDATE furumusic__podcast_episode SET download_until=now()+interval '15 minutes',download_error=NULL WHERE id=$1 AND cached_at IS NULL AND (download_until IS NULL OR download_until<now()) AND ($2 OR (NOT expired AND (retry_at IS NULL OR retry_at<now()))) RETURNING metadata")
.bind(id).bind(force).fetch_optional(pool).await?;
let Some(meta) = meta else { return Ok(()) };
let meta: EpisodeMeta = serde_json::from_value(meta)?;
let path = cache_path(config, id);
let temporary = path.with_extension("part");
let result: Result<()> = tokio::time::timeout(Duration::from_secs(12 * 60), async {
tokio::fs::create_dir_all(path.parent().context("missing cache directory")?).await?;
let response = fetch(&meta.audio_url, None, None).await?;
if response.content_length().is_some_and(|len| len > MAX_AUDIO_BYTES) { bail!("episode exceeds 2 GiB limit"); }
let expected = response.content_length();
let mut stream = response.bytes_stream();
let mut file = tokio::fs::File::create(&temporary).await?;
let mut length = 0;
while let Some(chunk) = stream.next().await {
let chunk = chunk?;
length += chunk.len() as u64;
if length > MAX_AUDIO_BYTES { bail!("episode exceeds 2 GiB limit"); }
file.write_all(&chunk).await?;
}
if length == 0 || expected.is_some_and(|size| size != length) { bail!("incomplete episode download"); }
file.flush().await?;
drop(file);
tokio::fs::rename(&temporary, &path).await?;
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=now(),download_until=NULL,retry_at=NULL,download_error=NULL,expired=false WHERE id=$1").bind(id).execute(pool).await?;
Ok(())
}).await.unwrap_or_else(|_| Err(anyhow::anyhow!("episode download timed out")));
if result.is_err() {
let _ = tokio::fs::remove_file(&temporary).await;
sqlx::query("UPDATE furumusic__podcast_episode SET download_until=NULL,retry_at=now()+interval '30 minutes',download_error='Download failed; will retry' WHERE id=$1").bind(id).execute(pool).await?;
}
result
}
pub(super) async fn download_pending(
pool: &PgPool,
config: &AppConfig,
podcast: Option<&str>,
) -> Result<()> {
let ids: Vec<String> = sqlx::query_scalar("SELECT e.id FROM furumusic__podcast_episode e WHERE cached_at IS NULL AND NOT expired AND ($1::text IS NULL OR podcast_id=$1) AND EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.podcast_id=e.podcast_id) AND (retry_at IS NULL OR retry_at<now()) ORDER BY discovered_at DESC LIMIT 100").bind(podcast).fetch_all(pool).await?;
futures_util::stream::iter(ids)
.for_each_concurrent(3, |id| async move {
let _ = download(pool, config, &id, false).await;
})
.await;
Ok(())
}
pub async fn reconcile(pool: &PgPool, overlay: &PodcastDht) -> Result<()> {
// Read the desired set only after acquiring the gate. An older pass must
// never publish its snapshot after a completed share-off/unsubscribe pass.
static GATE: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
let _guard = GATE.lock().await;
let rows = sqlx::query("SELECT p.*,s.confirmed_urls,s.user_id FROM furumusic__podcast p JOIN furumusic__podcast_subscription s ON s.podcast_id=p.id WHERE s.shared ORDER BY p.id").fetch_all(pool).await?;
let mut states = std::collections::BTreeMap::new();
for row in rows {
if !sync::publication_current(pool, row.get("user_id")).await? {
continue;
}
let id: String = row.get("id");
let meta: PodcastMeta = serde_json::from_value(row.get("metadata"))?;
let origin = FeedUrl::parse(row.get::<&str, _>("origin_url"))?;
let sub = SubscriptionRecord {
podcast_id: serde_json::from_value(json!(id))?,
subscribed: true,
podcast: meta,
feed_aliases: vec![origin],
generation: 1,
hlc_ms: 1,
op_id: "web-subscription".into(),
};
let card = PodcastCardSpec::from_subscription(&sub)?;
let confirmed: Option<Value> = row.get("confirmed_urls");
if !card.privacy_warnings().is_empty()
&& confirmed != Some(json!([card.feed_url, card.id_feed_url]))
{
continue;
}
let share = ShareRecord {
podcast_id: sub.podcast_id.clone(),
shared: true,
generation: 2,
hlc_ms: 2,
op_id: "web-share".into(),
};
states.insert(
id,
PodcastShareState {
subscription: sub,
share: Some(share),
card: Some(card),
privacy_confirmed: true,
},
);
}
overlay.sync_shares(states.into_values().collect()).await?;
Ok(())
}
pub struct PodcastRefreshJob;
#[async_trait::async_trait]
impl Job for PodcastRefreshJob {
fn name(&self) -> &'static str {
"podcast_refresh"
}
fn description(&self) -> &'static str {
"Check subscribed podcast feeds, download episodes and enforce cache retention"
}
fn default_cron(&self) -> &'static str {
"0 */30 * * * *"
}
async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> Result<()> {
let ids: Vec<String> =
sqlx::query_scalar("SELECT DISTINCT podcast_id FROM furumusic__podcast_subscription")
.fetch_all(&ctx.pool)
.await?;
let mut failed = 0;
for id in &ids {
if refresh(&ctx.pool, id).await.is_err() {
failed += 1;
sqlx::query("UPDATE furumusic__podcast SET last_error='Feed check failed',checked_at=now() WHERE id=$1").bind(id).execute(&ctx.pool).await?;
}
}
download_pending(&ctx.pool, &ctx.config, None).await?;
cleanup(&ctx.pool, &ctx.config).await?;
let _ = crate::federation::handle().sync_podcasts().await;
log.info(&format!(
"Checked {} podcast feeds; {} failed",
ids.len(),
failed
));
Ok(())
}
}
async fn cleanup(pool: &PgPool, config: &AppConfig) -> Result<()> {
let days: Option<i32> =
sqlx::query_scalar("SELECT retention_days FROM furumusic__podcast_settings WHERE id=1")
.fetch_one(pool)
.await?;
let Some(days) = days else { return Ok(()) };
let rows = sqlx::query(
"SELECT id,podcast_id FROM furumusic__podcast_episode WHERE cached_at<now()-make_interval(days=>$1)",
)
.bind(days)
.fetch_all(pool)
.await?;
for row in rows {
let id: String = row.get("id");
let podcast: String = row.get("podcast_id");
let mut tx = pool.begin().await?;
let locked: bool =
sqlx::query_scalar("SELECT pg_try_advisory_xact_lock(hashtextextended($1,7421))")
.bind(&podcast)
.fetch_one(&mut *tx)
.await?;
if !locked {
continue;
}
let expired: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__podcast_episode WHERE id=$1 AND cached_at<now()-make_interval(days=>$2))").bind(&id).bind(days).fetch_one(&mut *tx).await?;
if !expired {
continue;
}
match tokio::fs::remove_file(cache_path(config, &id)).await {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(_) => continue,
}
sqlx::query(
"UPDATE furumusic__podcast_episode SET cached_at=NULL,expired=true WHERE id=$1",
)
.bind(id)
.execute(&mut *tx)
.await?;
tx.commit().await?;
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn blocks_non_public_sources() {
for ip in [
"127.0.0.1",
"10.1.1.1",
"169.254.169.254",
"100.64.0.1",
"::1",
"::ffff:127.0.0.1",
"fc00::1",
] {
assert!(!public_address(ip.parse().unwrap()), "{ip}");
}
assert!(public_address("8.8.8.8".parse().unwrap()));
}
}
-32
View File
@@ -1,32 +0,0 @@
CREATE TABLE IF NOT EXISTS furumusic__podcast (
id TEXT PRIMARY KEY, origin_url TEXT NOT NULL UNIQUE, feed_url TEXT NOT NULL,
metadata JSONB NOT NULL, etag TEXT, modified TEXT, checked_at TIMESTAMPTZ,
last_error TEXT, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE IF NOT EXISTS furumusic__podcast_alias (
url TEXT PRIMARY KEY, podcast_id TEXT NOT NULL REFERENCES furumusic__podcast(id) ON DELETE CASCADE
);
CREATE TABLE IF NOT EXISTS furumusic__podcast_subscription (
user_id BIGINT NOT NULL REFERENCES furumusic__user(id) ON DELETE CASCADE,
podcast_id TEXT NOT NULL REFERENCES furumusic__podcast(id) ON DELETE CASCADE,
shared BOOLEAN NOT NULL DEFAULT false, confirmed_urls JSONB,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY(user_id,podcast_id)
);
CREATE TABLE IF NOT EXISTS furumusic__podcast_episode (
id TEXT PRIMARY KEY, podcast_id TEXT NOT NULL REFERENCES furumusic__podcast(id) ON DELETE CASCADE,
metadata JSONB NOT NULL, discovered_at TIMESTAMPTZ NOT NULL DEFAULT now(),
cached_at TIMESTAMPTZ, download_until TIMESTAMPTZ, retry_at TIMESTAMPTZ,
download_error TEXT, expired BOOLEAN NOT NULL DEFAULT false
);
CREATE INDEX IF NOT EXISTS idx_podcast_episode_feed ON furumusic__podcast_episode(podcast_id);
CREATE TABLE IF NOT EXISTS furumusic__podcast_progress (
user_id BIGINT NOT NULL REFERENCES furumusic__user(id) ON DELETE CASCADE,
episode_id TEXT NOT NULL REFERENCES furumusic__podcast_episode(id) ON DELETE CASCADE,
position_ms BIGINT NOT NULL DEFAULT 0, completed BOOLEAN NOT NULL DEFAULT false,
generation BIGINT NOT NULL DEFAULT 0, checkpoint BIGINT NOT NULL DEFAULT 0,
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY(user_id,episode_id)
);
CREATE TABLE IF NOT EXISTS furumusic__podcast_settings (
id INTEGER PRIMARY KEY CHECK(id=1), retention_days INTEGER CHECK(retention_days BETWEEN 1 AND 36500)
);
INSERT INTO furumusic__podcast_settings(id) VALUES(1) ON CONFLICT DO NOTHING;
-448
View File
@@ -1,448 +0,0 @@
//! Durable Frid podcast registers. Projections are user-scoped; revocations
//! remain here after a subscription is removed from the visible catalogue.
use super::*;
use music_dht::device_sync::{SyncOpPayload, SyncOpWire, SyncSnapshot};
use music_dht::podcast::{
ListenSession, ProgressRecord, ProgressStatus, effective_share, merge_listen_session,
merge_progress, merge_share, merge_subscription, next_podcast_generation,
};
use serde::{Serialize, de::DeserializeOwned};
use sqlx::{Postgres, Transaction};
fn current_users() -> &'static std::sync::Mutex<std::collections::HashSet<i64>> {
static USERS: std::sync::OnceLock<std::sync::Mutex<std::collections::HashSet<i64>>> =
std::sync::OnceLock::new();
USERS.get_or_init(Default::default)
}
pub async fn publication_current(pool: &PgPool, user: i64) -> Result<bool> {
if current_users()
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.contains(&user)
{
return Ok(true);
}
let peers:bool=sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__fed_device d WHERE user_id=$1 AND trusted_at_ms IS NOT NULL AND revoked_at_ms IS NULL AND protocol_version>=4 AND device_id<>(SELECT device_id FROM furumusic__fed_device_identity WHERE user_id=$1))").bind(user).fetch_one(pool).await?;
Ok(!peers)
}
pub async fn exchange_complete(pool: &PgPool, user: i64, peer: &str) -> Result<()> {
let version: Option<i32> = sqlx::query_scalar(
"SELECT protocol_version FROM furumusic__fed_device WHERE user_id=$1 AND device_id=$2",
)
.bind(user)
.bind(peer)
.fetch_optional(pool)
.await?;
if version.is_some_and(|v| v >= 4) {
current_users()
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.insert(user);
refresh_received(pool.clone());
tokio::spawn(async {
let _ = crate::federation::handle().sync_podcasts().await;
});
}
Ok(())
}
async fn get<T: DeserializeOwned>(
tx: &mut Transaction<'_, Postgres>,
user: i64,
kind: &str,
id: &str,
) -> Result<Option<T>> {
let value: Option<Value> = sqlx::query_scalar("SELECT value FROM furumusic__podcast_register WHERE user_id=$1 AND kind=$2 AND entity_id=$3").bind(user).bind(kind).bind(id).fetch_optional(&mut **tx).await?;
Ok(value.map(serde_json::from_value).transpose()?)
}
async fn put<T: Serialize>(
tx: &mut Transaction<'_, Postgres>,
user: i64,
kind: &str,
id: &str,
value: &T,
) -> Result<()> {
sqlx::query("INSERT INTO furumusic__podcast_register(user_id,kind,entity_id,value) VALUES($1,$2,$3,$4) ON CONFLICT(user_id,kind,entity_id) DO UPDATE SET value=EXCLUDED.value").bind(user).bind(kind).bind(id).bind(serde_json::to_value(value)?).execute(&mut **tx).await?;
Ok(())
}
async fn begin(pool: &PgPool, user: i64) -> Result<Transaction<'_, Postgres>> {
let mut tx = pool.begin().await?;
sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1,7512))")
.bind(format!("podcast-sync:{user}"))
.execute(&mut *tx)
.await?;
Ok(tx)
}
async fn project_subscription(
tx: &mut Transaction<'_, Postgres>,
user: i64,
id: &str,
) -> Result<()> {
let Some(sub) = get::<SubscriptionRecord>(tx, user, "subscription", id).await? else {
return Ok(());
};
let share = get::<ShareRecord>(tx, user, "share", id).await?;
let origin = sub
.feed_urls()
.into_iter()
.find(|url| PodcastId::from_feed_url(url) == sub.podcast_id)
.unwrap_or(sub.podcast.feed_url.clone());
sqlx::query("INSERT INTO furumusic__podcast(id,origin_url,feed_url,metadata) VALUES($1,$2,$3,$4) ON CONFLICT(id) DO UPDATE SET origin_url=EXCLUDED.origin_url").bind(id).bind(origin.as_str()).bind(sub.podcast.feed_url.as_str()).bind(json!(sub.podcast)).execute(&mut **tx).await?;
for alias in sub.feed_urls() {
sqlx::query("INSERT INTO furumusic__podcast_alias(url,podcast_id) VALUES($1,$2) ON CONFLICT DO NOTHING").bind(alias.as_str()).bind(id).execute(&mut **tx).await?;
}
if sub.subscribed {
let shared = effective_share(Some(&sub), share.as_ref());
sqlx::query("INSERT INTO furumusic__podcast_subscription(user_id,podcast_id,shared) VALUES($1,$2,$3) ON CONFLICT(user_id,podcast_id) DO UPDATE SET shared=EXCLUDED.shared,confirmed_urls=CASE WHEN EXCLUDED.shared THEN furumusic__podcast_subscription.confirmed_urls ELSE NULL END").bind(user).bind(id).bind(shared).execute(&mut **tx).await?;
} else {
sqlx::query(
"DELETE FROM furumusic__podcast_subscription WHERE user_id=$1 AND podcast_id=$2",
)
.bind(user)
.bind(id)
.execute(&mut **tx)
.await?;
}
Ok(())
}
async fn merge_sub(
tx: &mut Transaction<'_, Postgres>,
user: i64,
incoming: SubscriptionRecord,
) -> Result<()> {
incoming.validate()?;
let id = incoming.podcast_id.as_str();
let mut merged = match get::<SubscriptionRecord>(tx, user, "subscription", id).await? {
Some(current) => merge_subscription(&current, &incoming)?,
None => incoming.clone(),
};
if let Some(aliases) = get::<Vec<FeedUrl>>(tx, user, "aliases", id).await? {
merged.add_feed_aliases(&aliases);
}
put(tx, user, "subscription", id, &merged).await?;
project_subscription(tx, user, id).await
}
async fn merge_shared(
tx: &mut Transaction<'_, Postgres>,
user: i64,
incoming: ShareRecord,
local: bool,
) -> Result<()> {
let id = incoming.podcast_id.as_str();
let current = get::<ShareRecord>(tx, user, "share", id).await?;
let merged = match &current {
Some(current) => merge_share(current, &incoming)?,
None => incoming.clone(),
};
if !local && current.as_ref().map(|r| r.op_id.as_str()) != Some(merged.op_id.as_str()) {
sqlx::query("UPDATE furumusic__podcast_subscription SET confirmed_urls=NULL WHERE user_id=$1 AND podcast_id=$2").bind(user).bind(id).execute(&mut **tx).await?;
}
put(tx, user, "share", id, &merged).await?;
project_subscription(tx, user, id).await
}
async fn merge_resume(
tx: &mut Transaction<'_, Postgres>,
user: i64,
incoming: ProgressRecord,
) -> Result<()> {
incoming.validate()?;
let id = incoming.episode_id.as_str();
let merged = match get::<ProgressRecord>(tx, user, "progress", id).await? {
Some(current) => merge_progress(&current, &incoming)?,
None => incoming.clone(),
};
put(tx, user, "progress", id, &merged).await?;
project_resume(tx, user, &merged).await
}
async fn project_resume(
tx: &mut Transaction<'_, Postgres>,
user: i64,
record: &ProgressRecord,
) -> Result<()> {
sqlx::query("INSERT INTO furumusic__podcast_progress(user_id,episode_id,position_ms,completed,generation,checkpoint) SELECT $1,id,$3,$4,$5,0 FROM furumusic__podcast_episode WHERE id=$2 ON CONFLICT(user_id,episode_id) DO UPDATE SET position_ms=EXCLUDED.position_ms,completed=EXCLUDED.completed,generation=EXCLUDED.generation").bind(user).bind(record.episode_id.as_str()).bind(record.position_ms).bind(record.status==ProgressStatus::Completed).bind(record.generation.min(i64::MAX as u64) as i64).execute(&mut **tx).await?;
Ok(())
}
async fn merge_session(
tx: &mut Transaction<'_, Postgres>,
user: i64,
incoming: ListenSession,
) -> Result<()> {
incoming.validate()?;
let id = &incoming.session_id;
let merged = match get::<ListenSession>(tx, user, "session", id).await? {
Some(current) => merge_listen_session(&current, &incoming)?,
None => incoming.clone(),
};
put(tx, user, "session", id, &merged).await
}
/// Applying the same operation again is safe, including after a crash between
/// persisting its log entry and updating the projection.
pub async fn apply_op(pool: &PgPool, user: i64, op: &SyncOpWire) -> Result<bool> {
let mut tx = begin(pool, user).await?;
apply_op_tx(&mut tx, user, op).await?;
tx.commit().await?;
Ok(true)
}
pub(crate) async fn apply_op_tx(
tx: &mut Transaction<'_, Postgres>,
user: i64,
op: &SyncOpWire,
) -> Result<bool> {
op.validate_podcast()?;
let reference = match &op.payload {
SyncOpPayload::PodcastProgressSet { episode, .. }
| SyncOpPayload::PodcastListenRecorded { episode, .. } => episode.as_ref(),
_ => None,
};
if let Some(reference) = reference {
materialize_reference(tx, reference).await?;
}
if let Some(sub) = op.podcast_subscription() {
merge_sub(tx, user, sub).await?;
} else if let Some(share) = op.podcast_share() {
let local:bool=sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__fed_device_identity WHERE user_id=$1 AND device_id=$2)").bind(user).bind(&op.origin_device_id).fetch_one(&mut **tx).await?;
merge_shared(tx, user, share, local).await?;
} else if let Some((id, aliases)) = op.podcast_feed_aliases() {
let current = get::<Vec<FeedUrl>>(tx, user, "aliases", id.as_str())
.await?
.unwrap_or_default();
let merged = music_dht::podcast::merge_feed_aliases(id, &current, aliases);
put(tx, user, "aliases", id.as_str(), &merged).await?;
if let Some(mut sub) =
get::<SubscriptionRecord>(tx, user, "subscription", id.as_str()).await?
{
sub.add_feed_aliases(aliases);
put(tx, user, "subscription", id.as_str(), &sub).await?;
project_subscription(tx, user, id.as_str()).await?;
}
} else if let Some(progress) = op.podcast_progress() {
merge_resume(tx, user, progress).await?;
} else if let Some(session) = op.podcast_listen_session() {
merge_session(tx, user, session.clone()).await?;
}
Ok(true)
}
async fn materialize_reference(
tx: &mut Transaction<'_, Postgres>,
reference: &music_dht::podcast::PodcastEpisodeRef,
) -> Result<()> {
reference.validate()?;
let podcast = PodcastMeta {
feed_url: reference.feed_url.clone(),
title: reference.podcast_title.clone(),
author: None,
description: None,
link: None,
image_url: reference.image_url.clone(),
};
sqlx::query("INSERT INTO furumusic__podcast(id,origin_url,feed_url,metadata) VALUES($1,$2,$2,$3) ON CONFLICT DO NOTHING").bind(reference.podcast_id.as_str()).bind(reference.feed_url.as_str()).bind(json!(podcast)).execute(&mut **tx).await?;
let episode = EpisodeMeta {
episode_id: reference.episode_id.clone(),
podcast_id: reference.podcast_id.clone(),
guid: None,
title: reference.episode_title.clone(),
description: None,
season: reference.season,
episode_number: reference.episode_number,
episode_type: music_dht::podcast::EpisodeType::Full,
published_at_ms: reference.published_at_ms,
duration_ms: reference.duration_ms,
audio_url: reference.audio_url.clone(),
mime: reference.mime.clone(),
byte_len: None,
image_url: reference.image_url.clone(),
link: None,
};
sqlx::query("INSERT INTO furumusic__podcast_episode(id,podcast_id,metadata) VALUES($1,$2,$3) ON CONFLICT DO NOTHING").bind(reference.episode_id.as_str()).bind(reference.podcast_id.as_str()).bind(json!(episode)).execute(&mut **tx).await?;
Ok(())
}
pub async fn apply_snapshot(pool: &PgPool, user: i64, snapshot: &SyncSnapshot) -> Result<()> {
if !snapshot.podcast_state_within_limits() {
bail!("podcast snapshot exceeds contract limits");
}
let mut tx = begin(pool, user).await?;
for sub in &snapshot.podcast_subscriptions {
merge_sub(&mut tx, user, sub.clone()).await?;
}
for share in &snapshot.podcast_shares {
merge_shared(&mut tx, user, share.clone(), false).await?;
}
for progress in &snapshot.podcast_progress {
merge_resume(&mut tx, user, progress.clone()).await?;
}
for session in &snapshot.podcast_listen_sessions {
merge_session(&mut tx, user, session.clone()).await?;
}
tx.commit().await?;
Ok(())
}
pub async fn append_snapshot(pool: &PgPool, user: i64, snapshot: &mut SyncSnapshot) -> Result<()> {
seed_user(pool, user).await?;
let rows = sqlx::query(
"SELECT kind,value FROM furumusic__podcast_register WHERE user_id=$1 ORDER BY entity_id",
)
.bind(user)
.fetch_all(pool)
.await?;
for row in rows {
let value: Value = row.get("value");
match row.get::<&str, _>("kind") {
"subscription" => snapshot
.podcast_subscriptions
.push(serde_json::from_value(value)?),
"share" => snapshot.podcast_shares.push(serde_json::from_value(value)?),
"progress" => snapshot
.podcast_progress
.push(serde_json::from_value(value)?),
"session" => snapshot
.podcast_listen_sessions
.push(serde_json::from_value(value)?),
_ => {}
}
}
snapshot.bound_podcast_state();
Ok(())
}
pub async fn local_subscription(
pool: &PgPool,
user: i64,
id: &str,
subscribed: bool,
) -> Result<()> {
let mut tx = begin(pool, user).await?;
let sub = get::<SubscriptionRecord>(&mut tx, user, "subscription", id).await?;
let share = get::<ShareRecord>(&mut tx, user, "share", id).await?;
let generation = next_podcast_generation(sub.as_ref(), share.as_ref());
let row = sqlx::query("SELECT metadata,origin_url FROM furumusic__podcast WHERE id=$1")
.bind(id)
.fetch_one(&mut *tx)
.await?;
let podcast: PodcastMeta = serde_json::from_value(row.get("metadata"))?;
let origin = FeedUrl::parse(row.get::<&str, _>("origin_url"))?;
let mut aliases = sub.as_ref().map(|s| s.feed_urls()).unwrap_or_default();
aliases.push(origin);
let podcast_id: PodcastId = serde_json::from_value(json!(id))?;
let aliases = music_dht::podcast::merge_feed_aliases(&podcast_id, &[], &aliases);
tx.commit().await?;
crate::federation::devices::record_podcast_op(
pool,
user,
SyncOpPayload::PodcastSubscriptionSet {
podcast_id,
subscribed,
podcast,
feed_aliases: aliases,
generation,
},
)
.await?;
if !subscribed {
local_share(pool, user, id, false).await?;
}
Ok(())
}
pub async fn local_share(pool: &PgPool, user: i64, id: &str, shared: bool) -> Result<()> {
let mut tx = begin(pool, user).await?;
let sub = get::<SubscriptionRecord>(&mut tx, user, "subscription", id).await?;
let share = get::<ShareRecord>(&mut tx, user, "share", id).await?;
let generation = next_podcast_generation(sub.as_ref(), share.as_ref());
tx.commit().await?;
crate::federation::devices::record_podcast_op(
pool,
user,
SyncOpPayload::PodcastShareSet {
podcast_id: serde_json::from_value(json!(id))?,
shared,
generation,
},
)
.await
}
pub async fn seed_user(pool: &PgPool, user: i64) -> Result<()> {
let rows=sqlx::query("SELECT s.podcast_id,s.shared FROM furumusic__podcast_subscription s WHERE user_id=$1 AND NOT EXISTS(SELECT 1 FROM furumusic__podcast_register r WHERE r.user_id=s.user_id AND r.entity_id=s.podcast_id AND r.kind='subscription')").bind(user).fetch_all(pool).await?;
for row in rows {
let id: String = row.get("podcast_id");
let shared: bool = row.get("shared");
local_subscription(pool, user, &id, true).await?;
if shared {
local_share(pool, user, &id, true).await?;
}
}
Ok(())
}
pub async fn ensure_subscribed(pool: &PgPool, user: i64, id: &str) -> Result<()> {
let active:bool=sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__podcast_register WHERE user_id=$1 AND kind='subscription' AND entity_id=$2 AND value->>'subscribed'='true')").bind(user).bind(id).fetch_one(pool).await?;
if !active {
local_subscription(pool, user, id, true).await?;
}
Ok(())
}
pub async fn local_progress(
pool: &PgPool,
user: i64,
id: &str,
generation: u64,
position: i64,
completed: bool,
) -> Result<()> {
let row=sqlx::query("SELECT g.*,e.metadata AS episode,p.metadata AS podcast FROM furumusic__podcast_progress g JOIN furumusic__podcast_episode e ON e.id=g.episode_id JOIN furumusic__podcast p ON p.id=e.podcast_id WHERE g.user_id=$1 AND g.episode_id=$2").bind(user).bind(id).fetch_one(pool).await?;
let episode: EpisodeMeta = serde_json::from_value(row.get("episode"))?;
let podcast: PodcastMeta = serde_json::from_value(row.get("podcast"))?;
crate::federation::devices::record_podcast_op(
pool,
user,
SyncOpPayload::PodcastProgressSet {
episode_id: episode.episode_id.clone(),
podcast_id: episode.podcast_id.clone(),
position_ms: position,
status: if completed {
ProgressStatus::Completed
} else if position > 0 {
ProgressStatus::InProgress
} else {
ProgressStatus::NotStarted
},
generation,
session_id: format!("web:{user}:{id}:{generation}"),
episode: Some(episode.to_ref(&podcast)),
},
)
.await
}
pub async fn restore_episode_progress(tx: &mut Transaction<'_, Postgres>, id: &str) -> Result<()> {
let rows=sqlx::query("SELECT user_id,value FROM furumusic__podcast_register WHERE kind='progress' AND entity_id=$1").bind(id).fetch_all(&mut **tx).await?;
for row in rows {
project_resume(
tx,
row.get("user_id"),
&serde_json::from_value(row.get("value"))?,
)
.await?;
}
Ok(())
}
pub fn refresh_received(pool: PgPool) {
static WORKER: tokio::sync::Semaphore = tokio::sync::Semaphore::const_new(1);
let Ok(permit) = WORKER.try_acquire() else {
return;
};
tokio::spawn(async move {
let _permit = permit;
let ids:Vec<String>=sqlx::query_scalar("SELECT DISTINCT p.id FROM furumusic__podcast p JOIN furumusic__podcast_subscription s ON s.podcast_id=p.id WHERE p.checked_at IS NULL LIMIT 20").fetch_all(&pool).await.unwrap_or_default();
for id in ids {
let _ = refresh(&pool, &id).await;
}
});
}
-6
View File
@@ -1,6 +0,0 @@
CREATE TABLE IF NOT EXISTS furumusic__podcast_register (
user_id BIGINT NOT NULL REFERENCES furumusic__user(id) ON DELETE CASCADE,
kind TEXT NOT NULL, entity_id TEXT NOT NULL, value JSONB NOT NULL,
PRIMARY KEY(user_id,kind,entity_id)
);
CREATE COLLATION IF NOT EXISTS furumusic_unicode (provider=icu, locale='und', deterministic=true);
-402
View File
@@ -1,402 +0,0 @@
use super::*;
use cot::Template;
#[test]
fn episode_routes_accept_encoded_colons_and_reject_invalid_ids() {
let id = format!("ep1:{}", "a".repeat(52));
assert_eq!(episode_path_id(&id).unwrap().as_str(), id);
assert_eq!(
episode_path_id(&id.replace(':', "%3A")).unwrap().as_str(),
id
);
assert_eq!(
episode_path_id(&id.replace(':', "%3a")).unwrap().as_str(),
id
);
assert!(episode_path_id("../private").is_err());
}
#[test]
fn renders_podcast_navigation_and_views() {
let html = crate::player::PlayerPageTemplate {
t: crate::i18n::Translations::for_lang(crate::i18n::Lang::En),
guest: false,
share_token: String::new(),
downloads_enabled: true,
torrent_downloads_enabled: true,
youtube_downloads_enabled: true,
}
.render()
.unwrap();
assert_eq!(
html.matches("@click=\"$store.podcasts.enter()\"").count(),
2
);
assert!(html.contains("/api/podcasts/action"));
assert!(
html.find("Alpine.store('podcasts',").unwrap()
< html.find("Alpine.store('library',").unwrap(),
"podcast navigation must be registered before library.init restores the hash"
);
if std::env::var_os("FURU_PODCAST_RENDER_FIXTURE").is_some() {
std::fs::write("target/podcast-player-fixture.html", html).unwrap();
}
}
#[tokio::test]
#[ignore = "requires FURU_PODCAST_TEST_DATABASE_URL pointing to a disposable PostgreSQL database"]
async fn postgres_multiuser_progress_retention_and_admin() {
let url = std::env::var("FURU_PODCAST_TEST_DATABASE_URL").expect("disposable database URL");
let admin_pool = PgPool::connect(&url).await.unwrap();
let schema = format!("podcast_test_{}", uuid::Uuid::new_v4().simple());
sqlx::query(&format!("CREATE SCHEMA {schema}"))
.execute(&admin_pool)
.await
.unwrap();
let search_path = format!("SET search_path TO {schema}");
let pool = sqlx::postgres::PgPoolOptions::new()
.max_connections(8)
.after_connect(move |connection, _| {
let query = search_path.clone();
Box::pin(async move {
sqlx::query(&query).execute(connection).await?;
Ok(())
})
})
.connect(&url)
.await
.unwrap();
sqlx::query("CREATE TABLE furumusic__user(id BIGINT PRIMARY KEY)")
.execute(&pool)
.await
.unwrap();
for statement in include_str!("schema.sql")
.split(';')
.filter(|s| !s.trim().is_empty())
{
sqlx::query(statement).execute(&pool).await.unwrap();
}
// Repeatability matters for partially applied upgrades.
for statement in include_str!("schema.sql")
.split(';')
.filter(|s| !s.trim().is_empty())
{
sqlx::query(statement).execute(&pool).await.unwrap();
}
sqlx::query("INSERT INTO furumusic__user VALUES(1),(2)")
.execute(&pool)
.await
.unwrap();
for source in [
include_str!("sync_schema.sql"),
include_str!("../../tests/podcast_sync_fixture.sql"),
] {
for statement in source.split(';').filter(|s| !s.trim().is_empty()) {
sqlx::query(statement).execute(&pool).await.unwrap();
}
}
let origin = FeedUrl::parse("https://example.test/feed.xml").unwrap();
let podcast = PodcastId::from_feed_url(&origin);
let feed=parse_feed_with_base(br#"<rss><channel><title>Fixture</title><item><title>Episode</title><guid>one</guid><enclosure url="https://example.test/audio.mp3"/></item></channel></rss>"#,Some(origin.as_str())).unwrap();
let episode = feed.episodes[0].to_meta(
&podcast,
feed.resolve_episode_ids(&podcast, &[])[0].clone().unwrap(),
);
if std::env::var_os("FURU_PODCAST_RENDER_FIXTURE").is_some() {
std::fs::write("target/podcast-feed-fixture.json",json!({"id":podcast,"metadata":feed.to_podcast_meta(origin.clone()),"episode":episode,"cache_name":blake3::hash(episode.episode_id.as_str().as_bytes()).to_hex().to_string()}).to_string()).unwrap();
}
sqlx::query(
"INSERT INTO furumusic__podcast(id,origin_url,feed_url,metadata) VALUES($1,$2,$2,$3)",
)
.bind(podcast.as_str())
.bind(origin.as_str())
.bind(json!(feed.to_podcast_meta(origin.clone())))
.execute(&pool)
.await
.unwrap();
sqlx::query("INSERT INTO furumusic__podcast_subscription(user_id,podcast_id,shared) VALUES(1,$1,true),(2,$1,false)").bind(podcast.as_str()).execute(&pool).await.unwrap();
sqlx::query("INSERT INTO furumusic__podcast_episode(id,podcast_id,metadata) VALUES($1,$2,$3)")
.bind(episode.episode_id.as_str())
.bind(podcast.as_str())
.bind(json!(episode))
.execute(&pool)
.await
.unwrap();
let directory =
std::env::temp_dir().join(format!("furumusic-podcast-test-{}", uuid::Uuid::new_v4()));
let config = AppConfig {
agent_storage_dir: directory.to_string_lossy().into_owned(),
..AppConfig::default()
};
let media = cache_path(&config, episode.episode_id.as_str());
tokio::fs::create_dir_all(media.parent().unwrap())
.await
.unwrap();
tokio::fs::write(&media, b"saved episode").await.unwrap();
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=now()")
.execute(&pool)
.await
.unwrap();
let range_request = Request::builder()
.header("range", "bytes=0-4")
.body(Body::empty())
.unwrap();
let response = super::media(
&pool,
&config,
2,
episode.episode_id.as_str(),
&range_request,
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
assert_eq!(response.headers()["content-range"], "bytes 0-4/13");
assert_eq!(
response.into_body().into_bytes().await.unwrap().as_ref(),
b"saved"
);
let invalid_request = Request::builder()
.header("range", "bytes=900-1000")
.body(Body::empty())
.unwrap();
assert_eq!(
super::media(
&pool,
&config,
2,
episode.episode_id.as_str(),
&invalid_request
)
.await
.unwrap()
.status(),
StatusCode::RANGE_NOT_SATISFIABLE
);
assert!(
super::media(
&pool,
&config,
99,
episode.episode_id.as_str(),
&range_request
)
.await
.is_err()
);
assert_eq!(
list(&pool, 2, false).await.unwrap()["public"]
.as_array()
.unwrap()
.len(),
1
);
let request = |value| serde_json::from_value::<Action>(value).unwrap();
let preview = action(
pool.clone(),
config.clone(),
99,
false,
request(json!({"action":"detail","id":podcast})),
)
.await
.unwrap();
assert_eq!(preview["subscribed"], false);
let count: i64 =
sqlx::query_scalar("SELECT count(*) FROM furumusic__podcast_subscription WHERE user_id=99")
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(count, 0);
action(
pool.clone(),
config.clone(),
1,
false,
request(json!({"action":"remove","id":podcast})),
)
.await
.unwrap();
assert!(
action(
pool.clone(),
config.clone(),
99,
false,
request(json!({"action":"detail","id":podcast}))
)
.await
.is_err(),
"private podcasts must not be exposed by the detail route"
);
assert_eq!(
list(&pool, 2, false).await.unwrap()["mine"]
.as_array()
.unwrap()
.len(),
1
);
assert!(tokio::fs::try_exists(&media).await.unwrap());
let first = action(
pool.clone(),
config.clone(),
2,
false,
request(
json!({"action":"progress","id":episode.episode_id,"explicit":true,"position_ms":5000}),
),
)
.await
.unwrap();
let second = action(
pool.clone(),
config.clone(),
2,
false,
request(
json!({"action":"progress","id":episode.episode_id,"explicit":true,"position_ms":0}),
),
)
.await
.unwrap();
assert_eq!(
second["generation"].as_i64().unwrap(),
first["generation"].as_i64().unwrap() + 1
);
action(pool.clone(),config.clone(),2,false,request(json!({"action":"progress","id":episode.episode_id,"generation":first["generation"],"sequence":999,"position_ms":99999}))).await.unwrap();
let position: i64 = sqlx::query_scalar("SELECT position_ms FROM furumusic__podcast_progress")
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(position, 0);
assert!(
action(
pool.clone(),
config.clone(),
2,
false,
request(json!({"action":"admin_settings","retention_days":7}))
)
.await
.is_err()
);
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=now()-interval '20 days'")
.execute(&pool)
.await
.unwrap();
crate::podcasts::cleanup(&pool, &config).await.unwrap();
assert!(tokio::fs::try_exists(&media).await.unwrap());
action(
pool.clone(),
config.clone(),
1,
true,
request(json!({"action":"admin_settings","retention_days":7})),
)
.await
.unwrap();
crate::podcasts::cleanup(&pool, &config).await.unwrap();
assert!(!tokio::fs::try_exists(&media).await.unwrap());
let state: (bool,i64)=sqlx::query_as("SELECT expired,(SELECT count(*) FROM furumusic__podcast_progress) FROM furumusic__podcast_episode").fetch_one(&pool).await.unwrap();
assert_eq!(state, (true, 1));
action(
pool.clone(),
config.clone(),
1,
true,
request(json!({"action":"admin_delete","id":podcast})),
)
.await
.unwrap();
assert!(
list(&pool, 2, false).await.unwrap()["mine"]
.as_array()
.unwrap()
.is_empty()
);
// An actual v4 wire operation, as emitted by the TUI, creates the web
// subscription without HTTP fetching or a second manual subscription.
let url = FeedUrl::parse("https://example.test/tui-feed").unwrap();
let id = PodcastId::from_feed_url(&url);
let incoming:music_dht::device_sync::SyncOpWire=serde_json::from_value(json!({"op_id":"tui_test:1","origin_device_id":"tui_test","seq":1,"hlc_ms":42,"payload":{"kind":"podcast_subscription_set","podcast_id":id,"subscribed":true,"podcast":{"feed_url":url,"title":"ТАЙНЫ Космоса","description":"История МУЗЫКИ и Ελληνικά"},"feed_aliases":[url],"generation":1}})).unwrap();
sync::apply_op(&pool, 1, &incoming).await.unwrap();
assert_eq!(
list(&pool, 1, false).await.unwrap()["mine"][0]["id"],
json!(id)
);
assert_eq!(
super::super::search(&pool, 1, "тайны музыка", 10)
.await
.unwrap()
.len(),
0
);
for query in [
"тайны космоса",
"ТАЙНЫ КОСМОСА",
"история музыки",
"ελληνικά",
"ΕΛΛΗΝΙΚΆ",
] {
assert_eq!(
super::super::search(&pool, 1, query, 10)
.await
.unwrap()
.len(),
1,
"{query}"
);
}
assert!(
super::super::search(&pool, 2, "тайны", 10)
.await
.unwrap()
.is_empty()
);
let mut before = music_dht::device_sync::SyncSnapshot::default();
sync::append_snapshot(&pool, 1, &mut before).await.unwrap();
assert!(!before.for_peer(3).has_podcast_state());
// Simulate the same person's next connected device using another local
// user id, since local database user ids are not part of the wire contract.
sync::apply_snapshot(&pool, 2, &before).await.unwrap();
assert_eq!(
list(&pool, 2, false).await.unwrap()["mine"][0]["id"],
json!(id)
);
sync::local_subscription(&pool, 1, id.as_str(), false)
.await
.unwrap();
let mut after = music_dht::device_sync::SyncSnapshot::default();
sync::append_snapshot(&pool, 1, &mut after).await.unwrap();
sync::apply_snapshot(&pool, 2, &after).await.unwrap();
sync::apply_snapshot(&pool, 2, &before).await.unwrap();
sync::apply_op(&pool, 1, &incoming).await.unwrap();
assert!(
list(&pool, 1, false).await.unwrap()["mine"]
.as_array()
.unwrap()
.is_empty()
);
assert!(
list(&pool, 2, false).await.unwrap()["mine"]
.as_array()
.unwrap()
.is_empty()
);
let wire:music_dht::device_sync::SyncOpWire=serde_json::from_value(sqlx::query_scalar::<_,Value>("SELECT jsonb_build_object('op_id',op_id,'origin_device_id',origin_device_id,'seq',seq,'hlc_ms',hlc_ms,'payload',payload_json) FROM furumusic__fed_sync_ops WHERE user_id=1 AND kind='podcast_subscription_set' ORDER BY seq DESC LIMIT 1").fetch_one(&pool).await.unwrap()).unwrap();
assert!(!wire.podcast_subscription().unwrap().subscribed);
assert!(!music_dht::device_sync::op_allowed_for_peer(
&wire.payload,
3
));
assert!(music_dht::device_sync::op_allowed_for_peer(
&wire.payload,
4
));
pool.close().await;
sqlx::query(&format!("DROP SCHEMA {schema} CASCADE"))
.execute(&admin_pool)
.await
.unwrap();
tokio::fs::remove_dir_all(&directory).await.unwrap();
}
-475
View File
@@ -1,475 +0,0 @@
use super::*;
use crate::{auth, auth::Role};
use cot::http::{Request, StatusCode};
use cot::{
App, Body,
db::Database,
json::Json,
request::extractors::Path,
response::IntoResponse,
router::{
Route, Router,
method::{get, post},
},
session::Session,
};
use futures_util::TryStreamExt;
use serde::Deserialize;
use std::sync::Arc;
#[cfg(test)]
#[path = "tests.rs"]
mod tests;
#[derive(Deserialize)]
struct Action {
action: String,
#[serde(default)]
id: String,
#[serde(default)]
url: String,
#[serde(default)]
query: String,
#[serde(default)]
shared: bool,
#[serde(default)]
confirmed: bool,
#[serde(default)]
position_ms: i64,
#[serde(default)]
completed: bool,
#[serde(default)]
explicit: bool,
#[serde(default)]
generation: i64,
#[serde(default)]
sequence: i64,
#[serde(default)]
offset: i64,
retention_days: Option<i32>,
}
#[derive(Deserialize)]
struct EpisodePath {
id: String,
}
fn episode_path_id(value: &str) -> Result<music_dht::podcast::EpisodeId> {
// Cot's path extractor preserves percent escapes. The contract's only
// escaped path character is the colon separating the id prefix.
let decoded = value.replace("%3A", ":").replace("%3a", ":");
Ok(serde_json::from_value(json!(decoded))?)
}
fn error(status: StatusCode, message: &str) -> cot::Result<cot::response::Response> {
Ok(cot::http::Response::builder()
.status(status)
.header("Content-Type", "application/json")
.body(Body::fixed(json!({"error":message}).to_string()))
.expect("valid response"))
}
async fn list(pool: &PgPool, user: i64, admin: bool) -> Result<Value> {
let mine: Vec<Value> = sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'metadata',p.metadata,'shared',s.shared,'checked_at',p.checked_at,'error',p.last_error,'episodes',(SELECT count(*) FROM furumusic__podcast_episode e WHERE e.podcast_id=p.id),'new_episodes',(SELECT count(*) FROM furumusic__podcast_episode e WHERE e.podcast_id=p.id AND NOT EXISTS(SELECT 1 FROM furumusic__podcast_progress g WHERE g.user_id=$1 AND g.episode_id=e.id AND g.completed))) FROM furumusic__podcast p JOIN furumusic__podcast_subscription s ON s.podcast_id=p.id WHERE s.user_id=$1 ORDER BY p.metadata->>'title'").bind(user).fetch_all(pool).await?;
let public: Vec<Value> = sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'url',p.origin_url,'metadata',p.metadata,'subscribed',EXISTS(SELECT 1 FROM furumusic__podcast_subscription m WHERE m.user_id=$1 AND m.podcast_id=p.id)) FROM furumusic__podcast p WHERE EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id AND s.shared AND s.user_id<>$1) ORDER BY p.metadata->>'title' LIMIT 200").bind(user).fetch_all(pool).await?;
let mut result = json!({"mine":mine,"public":public});
if admin {
let all: Vec<Value> = sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'metadata',p.metadata,'error',p.last_error,'checked_at',p.checked_at,'subscribers',(SELECT count(*) FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id),'public',(SELECT count(*) FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id AND s.shared),'cached',(SELECT count(*) FROM furumusic__podcast_episode e WHERE e.podcast_id=p.id AND cached_at IS NOT NULL)) FROM furumusic__podcast p ORDER BY p.metadata->>'title'").fetch_all(pool).await?;
let days: Option<i32> =
sqlx::query_scalar("SELECT retention_days FROM furumusic__podcast_settings WHERE id=1")
.fetch_one(pool)
.await?;
result["all"] = json!(all);
result["retention_days"] = json!(days);
}
Ok(result)
}
async fn require_subscription(pool: &PgPool, user: i64, id: &str) -> Result<()> {
let yes: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__podcast_subscription WHERE user_id=$1 AND podcast_id=$2)").bind(user).bind(id).fetch_one(pool).await?;
if !yes {
bail!("podcast subscription not found");
}
Ok(())
}
async fn action(
pool: PgPool,
config: AppConfig,
user: i64,
admin: bool,
body: Action,
) -> Result<Value> {
if body.action.starts_with("admin_") && !admin {
bail!("administrator access required");
}
match body.action.as_str() {
"list" => return list(&pool, user, false).await,
"detail" => {
let detail:Option<Value>=sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'url',p.origin_url,'metadata',p.metadata,'subscribed',EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.user_id=$1 AND s.podcast_id=p.id),'episodes',(SELECT count(*) FROM furumusic__podcast_episode e WHERE e.podcast_id=p.id)) FROM furumusic__podcast p WHERE p.id=$2 AND EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id AND (s.user_id=$1 OR s.shared))").bind(user).bind(&body.id).fetch_optional(&pool).await?;
return detail.context("podcast not found");
}
"admin_list" => return list(&pool, user, true).await,
"add" => {
let id = subscribe(&pool, user, &body.url).await?;
sync::ensure_subscribed(&pool, user, &id).await?;
sync::seed_user(&pool, user).await?;
let checked = refresh(&pool, &id).await;
let download_id = id.clone();
tokio::spawn(async move {
let _ = download_pending(&pool, &config, Some(&download_id)).await;
});
return Ok(
json!({"ok":true,"id":id,"warning":checked.err().map(|_| "Feed check failed; the subscription was saved") }),
);
}
"remove" => {
require_subscription(&pool, user, &body.id).await?;
sync::local_subscription(&pool, user, &body.id, false).await?;
sqlx::query(
"DELETE FROM furumusic__podcast_subscription WHERE user_id=$1 AND podcast_id=$2",
)
.bind(user)
.bind(&body.id)
.execute(&pool)
.await?;
}
"share" => {
require_subscription(&pool, user, &body.id).await?;
sync::seed_user(&pool, user).await?;
let row = sqlx::query("SELECT origin_url,metadata FROM furumusic__podcast WHERE id=$1")
.bind(&body.id)
.fetch_one(&pool)
.await?;
let meta: PodcastMeta = serde_json::from_value(row.get("metadata"))?;
let origin = FeedUrl::parse(row.get::<&str, _>("origin_url"))?;
let sub = SubscriptionRecord {
podcast_id: serde_json::from_value(json!(body.id))?,
subscribed: true,
podcast: meta,
feed_aliases: vec![origin],
generation: 1,
hlc_ms: 1,
op_id: "web".into(),
};
let card = PodcastCardSpec::from_subscription(&sub)?;
let urls = json!([card.feed_url, card.id_feed_url]);
if body.shared && !body.confirmed && !card.privacy_warnings().is_empty() {
return Ok(json!({"confirmation_required":true,"urls":urls}));
}
sqlx::query("UPDATE furumusic__podcast_subscription SET shared=$3,confirmed_urls=$4 WHERE user_id=$1 AND podcast_id=$2").bind(user).bind(&body.id).bind(body.shared).bind(if body.shared {Some(urls)} else {None}).execute(&pool).await?;
sync::local_share(&pool, user, &body.id, body.shared).await?;
}
"episodes" => {
require_subscription(&pool, user, &body.id).await?;
let mut episodes: Vec<Value> = sqlx::query_scalar("SELECT jsonb_build_object('id',e.id,'metadata',e.metadata,'cached',e.cached_at IS NOT NULL,'downloading',COALESCE(e.download_until>now(),false),'error',e.download_error,'position_ms',COALESCE(g.position_ms,0),'completed',COALESCE(g.completed,false)) FROM furumusic__podcast_episode e LEFT JOIN furumusic__podcast_progress g ON g.episode_id=e.id AND g.user_id=$1 WHERE e.podcast_id=$2 ORDER BY (e.metadata->>'published_at_ms')::bigint DESC NULLS LAST,e.discovered_at DESC,e.id LIMIT 201 OFFSET $3").bind(user).bind(&body.id).bind(body.offset.max(0)).fetch_all(&pool).await?;
let more = episodes.len() > 200;
episodes.truncate(200);
return Ok(json!({"episodes":episodes,"has_more":more}));
}
"refresh" | "admin_refresh" => {
if body.action == "refresh" {
require_subscription(&pool, user, &body.id).await?;
}
let added = refresh(&pool, &body.id).await?;
tokio::spawn(async move {
let _ = download_pending(&pool, &config, Some(&body.id)).await;
});
return Ok(json!({"added":added}));
}
"download" | "progress" => {
let podcast: String =
sqlx::query_scalar("SELECT podcast_id FROM furumusic__podcast_episode WHERE id=$1")
.bind(&body.id)
.fetch_one(&pool)
.await?;
require_subscription(&pool, user, &podcast).await?;
if body.action == "download" {
tokio::spawn(async move {
let _ = download(&pool, &config, &body.id, true).await;
});
return Ok(json!({"ok":true}));
}
let duration: Option<i64> = sqlx::query_scalar("SELECT (metadata->>'duration_ms')::bigint FROM furumusic__podcast_episode WHERE id=$1").bind(&body.id).fetch_one(&pool).await?;
let completed = body.completed
|| (!body.explicit
&& music_dht::podcast::reaches_completion(body.position_ms, duration));
let generation: Option<i64> = if body.explicit {
Some(sqlx::query_scalar("INSERT INTO furumusic__podcast_progress(user_id,episode_id,position_ms,completed,generation,checkpoint) VALUES($1,$2,$3,$4,1,$5) ON CONFLICT(user_id,episode_id) DO UPDATE SET position_ms=EXCLUDED.position_ms,completed=EXCLUDED.completed,generation=furumusic__podcast_progress.generation+1,checkpoint=EXCLUDED.checkpoint,updated_at=now() RETURNING generation").bind(user).bind(&body.id).bind(body.position_ms.max(0)).bind(completed).bind(body.sequence).fetch_one(&pool).await?)
} else {
sqlx::query_scalar("UPDATE furumusic__podcast_progress SET position_ms=$3,completed=$4,checkpoint=$6,updated_at=now() WHERE user_id=$1 AND episode_id=$2 AND generation=$5 AND checkpoint<=$6 RETURNING generation").bind(user).bind(&body.id).bind(body.position_ms.max(0)).bind(completed).bind(body.generation).bind(body.sequence).fetch_optional(&pool).await?
};
if let Some(generation) = generation {
sync::local_progress(
&pool,
user,
&body.id,
generation.max(0) as u64,
body.position_ms.max(0),
completed,
)
.await?;
}
return Ok(json!({"ok":true,"generation":generation}));
}
"search" => {
if body.query.chars().count() < 2 || body.query.len() > 200 {
bail!("enter 2–200 characters");
}
let mut hits = super::search(&pool, user, &body.query, 100).await?;
if let Ok(Ok(Value::Array(remote))) = tokio::time::timeout(
Duration::from_secs(10),
crate::federation::handle().search_podcasts(&body.query),
)
.await
{
for hit in remote {
if !hits.iter().any(|local| local["id"] == hit["id"]) {
hits.push(hit);
}
}
}
return Ok(json!({"hits":hits}));
}
"admin_settings" => {
if body
.retention_days
.is_some_and(|days| !(1..=36500).contains(&days))
{
bail!("retention must be between 1 and 36500 days");
}
sqlx::query("UPDATE furumusic__podcast_settings SET retention_days=$1 WHERE id=1")
.bind(body.retention_days)
.execute(&pool)
.await?;
}
"admin_unpublish" => {
let owners:Vec<i64>=sqlx::query_scalar("SELECT user_id FROM furumusic__podcast_subscription WHERE podcast_id=$1 AND shared").bind(&body.id).fetch_all(&pool).await?;
for owner in owners {
sync::seed_user(&pool, owner).await?;
sync::local_share(&pool, owner, &body.id, false).await?;
}
sqlx::query("UPDATE furumusic__podcast_subscription SET shared=false,confirmed_urls=NULL WHERE podcast_id=$1").bind(&body.id).execute(&pool).await?;
}
"admin_clear" | "admin_delete" => {
if body.action == "admin_delete" {
let owners: Vec<i64> = sqlx::query_scalar(
"SELECT user_id FROM furumusic__podcast_subscription WHERE podcast_id=$1",
)
.bind(&body.id)
.fetch_all(&pool)
.await?;
for owner in owners {
sync::local_subscription(&pool, owner, &body.id, false).await?;
}
}
let mut tx = pool.begin().await?;
let locked: bool =
sqlx::query_scalar("SELECT pg_try_advisory_xact_lock(hashtextextended($1,7421))")
.bind(&body.id)
.fetch_one(&mut *tx)
.await?;
if !locked {
bail!("downloads are running; try again when they finish");
}
sqlx::query("SELECT id FROM furumusic__podcast WHERE id=$1 FOR UPDATE")
.bind(&body.id)
.fetch_optional(&mut *tx)
.await?;
let ids: Vec<String> =
sqlx::query_scalar("SELECT id FROM furumusic__podcast_episode WHERE podcast_id=$1")
.bind(&body.id)
.fetch_all(&pool)
.await?;
// A leased download must finish before clearing or deleting its catalogue.
let busy: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__podcast_episode WHERE podcast_id=$1 AND download_until>now())").bind(&body.id).fetch_one(&pool).await?;
if busy {
bail!("downloads are running; try again when they finish");
}
for id in ids {
match tokio::fs::remove_file(cache_path(&config, &id)).await {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) => return Err(e.into()),
}
}
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=NULL,expired=true WHERE podcast_id=$1").bind(&body.id).execute(&mut *tx).await?;
if body.action == "admin_delete" {
sqlx::query("DELETE FROM furumusic__podcast WHERE id=$1")
.bind(&body.id)
.execute(&mut *tx)
.await?;
}
tx.commit().await?;
}
_ => bail!("unknown podcast action"),
}
let federation = crate::federation::handle();
let pending = federation.sync_podcasts().await.is_err();
Ok(json!({"ok":true,"publication_pending":pending}))
}
async fn media(
pool: &PgPool,
config: &AppConfig,
user: i64,
id: &str,
request: &Request<Body>,
) -> Result<cot::response::Response> {
let row = sqlx::query("SELECT e.metadata,e.cached_at IS NOT NULL AS cached FROM furumusic__podcast_episode e JOIN furumusic__podcast_subscription s ON s.podcast_id=e.podcast_id WHERE e.id=$1 AND s.user_id=$2").bind(id).bind(user).fetch_one(pool).await?;
let meta: EpisodeMeta = serde_json::from_value(row.get("metadata"))?;
let range = request.headers().get("range").and_then(|v| v.to_str().ok());
let mut builder = cot::http::Response::builder().header("Cache-Control", "private, no-store");
let path = cache_path(config, id);
if row.get::<bool, _>("cached") && tokio::fs::try_exists(&path).await? {
use tokio::io::{AsyncReadExt, AsyncSeekExt};
let mut file = tokio::fs::File::open(&path).await?;
let size = file.metadata().await?.len();
let (start, end) = if let Some(range) = range {
match crate::player::parse_range(range, size) {
Some((start, end)) => {
builder = builder
.status(206)
.header("Content-Range", format!("bytes {start}-{end}/{size}"));
(start, end)
}
None => {
return Ok(builder
.status(416)
.header("Content-Range", format!("bytes */{size}"))
.body(Body::empty())?);
}
}
} else {
(0, size.saturating_sub(1))
};
file.seek(std::io::SeekFrom::Start(start)).await?;
let stream = tokio_util::io::ReaderStream::new(file.take(end - start + 1))
.map_err(|e| cot::Error::internal(e.to_string()));
return Ok(builder
.header("Content-Type", meta.mime.as_deref().unwrap_or("audio/mpeg"))
.header("Accept-Ranges", "bytes")
.header("Content-Length", (end - start + 1).to_string())
.body(Body::streaming(stream))?);
}
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=NULL WHERE id=$1")
.bind(id)
.execute(pool)
.await?;
let pool_clone = pool.clone();
let config_clone = config.clone();
let id_clone = id.to_owned();
tokio::spawn(async move {
let _ = download(&pool_clone, &config_clone, &id_clone, true).await;
});
let response = fetch(&meta.audio_url, range, None).await?;
builder = builder.status(response.status());
for key in [
"content-type",
"content-length",
"content-range",
"accept-ranges",
] {
if let Some(value) = response.headers().get(key) {
builder = builder.header(key, value);
}
}
let stream = response
.bytes_stream()
.map_err(|_| cot::Error::internal("podcast stream interrupted"));
Ok(builder.body(Body::streaming(stream))?)
}
pub struct PodcastApp {
config: Arc<AppConfig>,
}
impl PodcastApp {
pub fn new(config: Arc<AppConfig>) -> Self {
Self { config }
}
}
impl App for PodcastApp {
fn name(&self) -> &'static str {
"podcasts"
}
fn router(&self) -> Router {
let pool = sqlx::postgres::PgPoolOptions::new()
.max_connections(8)
.connect_lazy(&self.config.database_url)
.expect("podcast pool configuration");
let action_pool = pool.clone();
Router::with_urls([
Route::with_handler_and_name(
"/action",
{
post(
move |auth_ctx: auth::AuthContext,
session: Session,
db: Database,
Json(body): Json<Action>| {
let pool = action_pool.clone();
async move {
let Some(user) =
auth::get_request_user(&auth_ctx, &session, &db).await
else {
return error(StatusCode::UNAUTHORIZED, "not authenticated");
};
if body.action.starts_with("admin_") && user.role != Role::Admin {
return error(
StatusCode::FORBIDDEN,
"administrator access required",
);
}
let (config, _) = AppConfig::load_with_db(&db).await;
match action(pool, config, user.id, user.role == Role::Admin, body)
.await
{
Ok(value) => Json(value).into_response(),
Err(err) => {
let message = if err.downcast_ref::<sqlx::Error>().is_some()
{
"Podcast storage operation failed; try again".to_owned()
} else {
err.to_string()
};
error(StatusCode::BAD_REQUEST, &message)
}
}
}
},
)
},
"podcast_action",
),
Route::with_handler_and_name(
"/media/{id}",
{
get(
move |auth_ctx: auth::AuthContext,
session: Session,
db: Database,
path: Path<EpisodePath>,
request: Request<Body>| {
let pool = pool.clone();
async move {
let Some(user) =
auth::get_request_user(&auth_ctx, &session, &db).await
else {
return error(StatusCode::UNAUTHORIZED, "not authenticated");
};
let (config, _) = AppConfig::load_with_db(&db).await;
let Ok(id) = episode_path_id(&path.0.id) else {
return error(StatusCode::NOT_FOUND, "episode unavailable");
};
match media(&pool, &config, user.id, id.as_str(), &request).await {
Ok(response) => Ok(response),
Err(_) => error(StatusCode::NOT_FOUND, "episode unavailable"),
}
}
},
)
},
"podcast_media",
),
])
}
}
-193
View File
@@ -1,193 +0,0 @@
<section
class="panel settings-section"
id="settings-podcasts"
x-data="podcastAdmin()"
x-effect="if(activeView!=='settings')visible=false"
>
<div class="panel-head">
<div class="panel-title">
<strong>Podcasts</strong><span>Shared catalogue, publications and audio retention</span>
</div>
<button type="button" class="btn" @click="open()">Manage podcasts</button>
</div>
<div
class="modal-backdrop"
x-show="visible"
x-cloak
x-effect="adminOverlay.sync($el, visible)"
@keydown="adminOverlay.keydown($event, $el)"
@keydown.escape.window="visible=false"
@click.self="visible=false"
>
<section
class="modal"
role="dialog"
aria-modal="true"
aria-labelledby="podcast-admin-title"
tabindex="-1"
style="width:min(1000px,95vw);max-height:90vh;overflow:auto"
>
<header class="modal-head">
<h2 id="podcast-admin-title">Instance podcasts</h2>
<button
class="btn"
data-dialog-close
aria-label="Close podcasts"
@click="visible=false"
>
Close
</button>
</header>
<div class="modal-body">
<p>
Shared catalogue for all users. Clearing audio keeps subscriptions and listening
progress. Deleting a podcast removes it for every subscriber.
</p>
<form class="toolbar" @submit.prevent="save()">
<label
><input type="checkbox" x-model="retention" /> Automatically remove saved
audio</label
><label
>Keep for
<input
class="search"
type="number"
min="1"
max="36500"
required
x-model.number="days"
:disabled="!retention"
style="width:100px"
/>
days after download</label
><button class="btn" :disabled="busy">Save retention</button>
</form>
<p class="muted">
Disabled by default. Episode metadata remains available; expired audio can be
saved again manually. Feed checks run in the internal “podcast_refresh”
scheduled job.
</p>
<div role="status" aria-live="polite" x-text="message"></div>
<input
class="search"
x-model="filter"
placeholder="Filter podcasts"
aria-label="Filter podcasts"
style="margin:12px 0;width:100%"
/>
<p x-show="!items.length">No known podcasts.</p>
<template
x-for="pod in items.filter(p=>(p.metadata.title+' '+p.metadata.feed_url).toLowerCase().includes(filter.toLowerCase()))"
:key="pod.id"
><article
class="panel"
style="padding:16px;margin:12px 0;overflow-wrap:anywhere"
>
<h3 x-text="pod.metadata.title"></h3>
<p x-text="pod.metadata.feed_url"></p>
<p
x-text="pod.subscribers+' subscribers · '+pod.public+' publications · '+pod.cached+' saved episodes'"
></p>
<p x-show="pod.error" x-text="pod.error"></p>
<div class="toolbar">
<button class="btn" :disabled="busy" @click="run('admin_refresh',pod)">
Check episodes</button
><button
class="btn"
:disabled="busy"
@click="run('admin_unpublish',pod)"
>
Unpublish</button
><button class="btn" :disabled="busy" @click="run('admin_clear',pod)">
Clear saved audio</button
><button
class="btn danger"
:disabled="busy"
@click="run('admin_delete',pod)"
>
Delete for all users
</button>
</div>
</article></template
>
</div>
</section>
</div>
</section>
<script>
function podcastAdmin() {
return {
visible: false,
busy: false,
items: [],
filter: '',
retention: false,
days: 30,
message: '',
async api(action, body = {}) {
const res = await fetch('/api/podcasts/action', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action, ...body }),
});
const data = await res.json();
if (!res.ok) throw new Error(data.error || 'Podcast operation failed');
return data;
},
async load() {
const data = await this.api('admin_list');
this.items = data.all;
this.retention = data.retention_days !== null;
this.days = data.retention_days || 30;
},
async open() {
this.visible = true;
this.busy = true;
try {
await this.load();
this.message = '';
} catch (e) {
this.message = e.message;
} finally {
this.busy = false;
}
},
async save() {
this.busy = true;
try {
await this.api('admin_settings', {
retention_days: this.retention ? Number(this.days) : null,
});
this.message = 'Retention settings saved';
} catch (e) {
this.message = e.message;
} finally {
this.busy = false;
}
},
async run(action, pod) {
if (
action !== 'admin_refresh' &&
!confirm(
action === 'admin_delete'
? 'Delete this podcast and ALL users’ subscriptions and progress?'
: 'Apply this action to the shared podcast for every user?',
)
)
return;
this.busy = true;
try {
const result = await this.api(action, { id: pod.id });
await this.load();
this.message = result.publication_pending
? 'Saved; Frid publication reconciliation is pending.'
: 'Done';
} catch (e) {
this.message = e.message;
} finally {
this.busy = false;
}
},
};
}
</script>
+1 -2
View File
@@ -631,10 +631,9 @@
<div class="settings-page">
<label class="section-jump">Settings section
<select class="search" @change="jumpToSettings($event.target.value)">
<option value="access">Access</option><option value="oidc">SSO</option><option value="agent">Import agent</option><option value="similarity">Similarity</option><option value="downloads">Downloads</option><option value="podcasts">Podcasts</option><option value="federation">Federation</option><option value="lastfm">Last.fm</option><option value="developer">Developer</option>
<option value="access">Access</option><option value="oidc">SSO</option><option value="agent">Import agent</option><option value="similarity">Similarity</option><option value="downloads">Downloads</option><option value="federation">Federation</option><option value="lastfm">Last.fm</option><option value="developer">Developer</option>
</select>
</label>
{% include "admin/podcasts.html" %}
<form class="settings-layout" @submit.prevent="saveSettings()">
<div class="settings-column">
<section class="panel settings-section settings-section-wide settings-oidc" id="settings-oidc">
-2
View File
@@ -4,12 +4,10 @@
{% block head_extra %}
{% include "player/styles.html" %}
{% include "player/podcast_styles.html" %}
{% endblock head_extra %}
{% block body %}
{% include "player/shell.html" %}
{% include "player/modals.html" %}
{% include "player/podcast_scripts.html" %}
{% include "player/scripts.html" %}
{% endblock body %}
-23
View File
@@ -1,23 +0,0 @@
<template x-if="$store.podcasts.artwork(pod)">
<img
:src="$store.podcasts.artwork(pod)"
alt=""
aria-hidden="true"
loading="lazy"
decoding="async"
referrerpolicy="no-referrer"
@error="$store.podcasts.artworkFailed(pod)"
/>
</template>
<template x-if="!$store.podcasts.artwork(pod)">
<svg
viewBox="0 0 24 24"
fill="none"
stroke="currentColor"
stroke-width="1.5"
aria-hidden="true"
>
<rect x="9" y="2" width="6" height="13" rx="3" />
<path d="M5 10v2a7 7 0 0014 0v-2M12 19v3M8 22h8" />
</svg>
</template>
-18
View File
@@ -1,18 +0,0 @@
<button
type="button"
class="card podcast-tile"
@click="$store.podcasts.open(pod)"
:title="pod.metadata.title"
>
<div class="card-img podcast-artwork">{% include "player/podcast_artwork.html" %}</div>
<div class="card-title" x-text="pod.metadata.title"></div>
<div
class="card-subtitle"
x-text="pod.metadata.author || $store.podcasts.text('podcasts')"
></div>
<div
class="card-subtitle"
x-show="pod.episodes != null"
x-text="(pod.episodes || 0) + ' ' + $store.podcasts.text('episodes') + (pod.new_episodes ? ' · ' + pod.new_episodes + ' ' + $store.podcasts.text('unplayed') : '')"
></div>
</button>
-61
View File
@@ -1,61 +0,0 @@
<h2 class="podcast-section-title" x-text="$store.podcasts.text('episodes')"></h2>
<div class="podcast-toolbar">
<input
type="text"
x-model="$store.podcasts.filter"
:placeholder="$store.podcasts.text('filter')"
:aria-label="$store.podcasts.text('filter')"
/><select x-model="$store.podcasts.season" :aria-label="$store.podcasts.text('season')">
<option value="" x-text="$store.podcasts.text('allSeasons')"></option>
<template x-for="season in $store.podcasts.seasons()" :key="season"
><option :value="season" x-text="$store.podcasts.text('season')+' '+season"></option
></template></select
><label
><input type="checkbox" x-model="$store.podcasts.unplayedOnly" />
<span x-text="$store.podcasts.text('unplayedOnly')"></span
></label>
</div>
<p
x-show="!$store.podcasts.filteredEpisodes().length"
x-text="$store.podcasts.text('noEpisodes')"
></p>
<template x-for="episode in $store.podcasts.filteredEpisodes()" :key="episode.id"
><article class="podcast-episode">
<h3 x-text="episode.metadata.title"></h3>
<div x-text="$store.podcasts.date(episode.metadata.published_at_ms)"></div>
<details x-show="episode.metadata.description">
<summary x-text="$store.podcasts.text('description')"></summary>
<p class="podcast-description" x-text="episode.metadata.description"></p>
</details>
<div class="podcast-toolbar">
<button
class="release-action-btn secondary"
@click="$store.podcasts.play(episode)"
x-text="$store.podcasts.text(episode.position_ms&&!episode.completed?'resume':'play')"
></button
><button
class="release-action-btn secondary"
@click="$store.podcasts.download(episode)"
:disabled="episode.cached||episode.downloading"
x-text="$store.podcasts.text(episode.cached?'saved':episode.downloading?'downloading':'download')"
></button
><button
class="release-action-btn secondary"
@click="$store.podcasts.mark(episode)"
x-text="$store.podcasts.text(episode.completed?'markUnplayed':'markPlayed')"
></button
><button
class="release-action-btn secondary"
x-show="episode.position_ms"
@click="$store.podcasts.restart(episode)"
x-text="$store.podcasts.text('restart')"
></button>
</div>
<div role="status" x-show="episode.error" x-text="episode.error"></div></article></template
><button
class="release-action-btn secondary"
x-show="$store.podcasts.hasMore"
@click="$store.podcasts.more()"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text('loadMore')"
></button>
-490
View File
@@ -1,490 +0,0 @@
<script>
document.addEventListener('alpine:init', () => {
const labels = {
podcasts: ['Podcasts', 'Подкасты'],
episodes: ['Episodes', 'Выпуски'],
subscribeHint: [
'Subscribe to listen and save episodes.',
'Подпишитесь, чтобы слушать и сохранять выпуски.',
],
notFound: ['Podcast not found.', 'Подкаст не найден.'],
showMore: ['Show more', 'Подробнее'],
showLess: ['Show less', 'Свернуть'],
add: ['Add', 'Добавить'],
mine: ['My podcasts', 'Мои подкасты'],
public: ['Public podcasts', 'Публичные подкасты'],
results: ['Podcast search results', 'Результаты поиска подкастов'],
noMatches: ['No matching podcasts.', 'Подходящих подкастов нет.'],
empty: ['Add an RSS or Atom feed.', 'Добавьте RSS или Atom ленту.'],
check: ['Check episodes', 'Проверить выпуски'],
checkAll: ['Check all', 'Проверить все'],
publish: ['Publish', 'Опубликовать'],
unpublish: ['Unpublish', 'Снять публикацию'],
remove: ['Unsubscribe', 'Отписаться'],
subscribe: ['Subscribe', 'Подписаться'],
play: ['Play', 'Слушать'],
open: ['Open', 'Открыть'],
resume: ['Resume', 'Продолжить'],
download: ['Save on server', 'Сохранить на сервере'],
saved: ['Saved on server', 'Сохранено на сервере'],
downloading: ['Downloading…', 'Скачивается…'],
markPlayed: ['Mark played', 'Прослушано'],
markUnplayed: ['Mark unplayed', 'Не прослушано'],
restart: ['Start over', 'С начала'],
filter: ['Filter episodes', 'Поиск выпусков'],
season: ['Season', 'Сезон'],
allSeasons: ['All seasons', 'Все сезоны'],
unplayed: ['unplayed', 'не прослушано'],
unplayedOnly: ['Unplayed only', 'Только непрослушанные'],
description: ['Description', 'Описание'],
noEpisodes: ['No episodes in this filter.', 'В этом фильтре нет выпусков.'],
noPublic: ['No public podcasts yet.', 'Публичных подкастов пока нет.'],
searchNetwork: ['Search podcasts', 'Поиск подкастов'],
search: ['Search', 'Найти'],
working: ['Working…', 'Выполняется…'],
done: ['Done', 'Готово'],
removeConfirm: [
'Remove only your subscription? Other subscribers keep access.',
'Удалить только вашу подписку? Доступ других подписчиков сохранится.',
],
shareConfirm: [
'Publish this feed URL to other users and Frid?',
'Опубликовать ссылку на ленту для других пользователей и Frid?',
],
privateConfirm: [
'This URL may contain private access credentials. Publish these exact URLs?',
'Ссылка может содержать приватный токен доступа. Опубликовать именно эти ссылки?',
],
pending: [
'Saved. Frid publication will retry when federation is available.',
'Сохранено. Публикация в Frid повторится, когда федерация будет доступна.',
],
checked: ['New episodes: ', 'Новых выпусков: '],
failed: [
'Operation failed. Please try again.',
'Не удалось выполнить действие. Повторите попытку.',
],
};
Alpine.store('podcasts', {
mine: [],
public: [],
hits: [],
searched: false,
episodes: [],
hasMore: false,
selected: null,
selectedId: null,
loading: false,
adding: false,
failedArtwork: {},
descriptionExpanded: false,
_navigation: 0,
url: '',
query: '',
filter: '',
season: '',
unplayedOnly: false,
busy: false,
message: '',
poller: null,
lastCheckpoint: 0,
text(key) {
if (key === 'loadMore')
return document.documentElement.lang.startsWith('ru')
? 'Загрузить ещё выпуски'
: 'Load more episodes';
return labels[key]?.[document.documentElement.lang.startsWith('ru') ? 1 : 0] || key;
},
async api(action, body = {}) {
const res = await fetch('/api/podcasts/action', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action, ...body }),
});
const data = await res.json();
if (!res.ok) throw new Error(data.error || this.text('failed'));
return data;
},
async task(fn) {
if (this.busy) return;
this.busy = true;
this.message = this.text('working');
try {
await fn();
} catch (e) {
this.message = e.message || this.text('failed');
} finally {
this.busy = false;
}
},
async load() {
const data = await this.api('list');
this.mine = data.mine.map((pod) => ({ ...pod, subscribed: true }));
this.public = data.public;
if (this.selected) {
const current =
this.mine.find((p) => p.id === this.selected.id) ||
this.public.find((p) => p.id === this.selected.id);
this.selected = {
...this.selected,
...current,
subscribed: this.mine.some((p) => p.id === this.selected.id),
};
}
},
artwork(pod) {
const url = pod?.metadata?.image_url;
return url && !this.failedArtwork[url] ? url : null;
},
artworkFailed(pod) {
const url = pod?.metadata?.image_url;
if (url) this.failedArtwork[url] = true;
},
description(pod) {
const text = pod?.metadata?.description || '';
return !this.descriptionExpanded && text.length > 360
? text.slice(0, 360).trimEnd() + '…'
: text;
},
navigate(hash, view, options = {}) {
const library = Alpine.store('library');
library._beginNavigation(hash, options);
library.view = view;
library.currentArtist = null;
library.currentRelease = null;
library.currentPlaylist = null;
Alpine.store('mobile')?.closeLibrary();
this.ensurePolling();
},
ensurePolling() {
if (!this.poller)
this.poller = setInterval(() => {
if (
['podcasts', 'podcast_detail'].includes(Alpine.store('library').view) &&
!this.busy &&
!this.loading
)
this.update().catch(() => {});
}, 5000);
},
async enter(options = {}) {
const token = ++this._navigation;
this.navigate('#podcasts', 'podcasts', options);
this.selected = null;
this.selectedId = null;
this.episodes = [];
this.message = '';
this.loading = true;
try {
await this.load();
} catch (error) {
if (token === this._navigation) this.message = error.message;
} finally {
if (token === this._navigation) {
this.loading = false;
Alpine.store('library')._afterNavigation(options);
}
}
},
async update() {
await this.load();
if (this.selected?.subscribed) await this.loadEpisodes();
else this.episodes = [];
},
async loadEpisodes(append = false) {
const id = this.selected.id;
const offset = append ? this.episodes.length : 0;
const data = await this.api('episodes', { id, offset });
if (this.selected?.id !== id) return;
const old = this.episodes;
this.episodes = append
? [...old, ...data.episodes]
: [...new Map([...data.episodes, ...old].map((e) => [e.id, e])).values()];
if (append || old.length <= 200) this.hasMore = !!data.has_more;
},
more() {
return this.task(async () => {
await this.loadEpisodes(true);
this.message = '';
});
},
async open(pod, options = {}) {
const id = typeof pod === 'string' ? pod : pod.id;
const token = ++this._navigation;
this.selectedId = id;
this.descriptionExpanded = false;
const cached =
this.mine.find((p) => p.id === id) ||
this.public.find((p) => p.id === id) ||
(typeof pod === 'object' ? pod : null);
this.selected = cached
? {
...cached,
subscribed: this.mine.some((p) => p.id === id) || !!cached.subscribed,
}
: null;
this.episodes = [];
this.hasMore = false;
this.filter = '';
this.season = '';
this.message = '';
this.loading = true;
this.navigate('#podcast?id=' + encodeURIComponent(id), 'podcast_detail', options);
try {
await this.load();
if (token !== this._navigation) return;
const detail =
this.mine.find((p) => p.id === id) ||
this.public.find((p) => p.id === id) ||
this.selected ||
(await this.api('detail', { id }));
if (token !== this._navigation) return;
this.selected = { ...detail, subscribed: this.mine.some((p) => p.id === id) };
if (this.selected.subscribed) await this.loadEpisodes();
} catch (error) {
if (token === this._navigation)
this.message = error.message || this.text('notFound');
} finally {
if (token === this._navigation) {
this.loading = false;
Alpine.store('library')._afterNavigation(options);
}
}
},
openResult(pod) {
return this.open(pod);
},
subscribe(pod = this.selected) {
return this.task(async () => {
await this.api('add', { url: pod.url || pod.metadata.feed_url });
await this.load();
if (this.selectedId === pod.id) {
this.selected = this.mine.find((p) => p.id === pod.id) || {
...pod,
subscribed: true,
};
await this.loadEpisodes();
}
this.message = '';
});
},
add(url) {
this.task(async () => {
const result = await this.api('add', { url: url || this.url });
this.url = '';
await this.load();
this.adding = false;
if (result.id) await this.open(result.id);
this.message = result.warning || this.text('done');
});
},
remove(pod) {
if (!confirm(this.text('removeConfirm'))) return;
this.task(async () => {
const result = await this.api('remove', { id: pod.id });
if (this.selected?.id === pod.id) {
++this._navigation;
this.loading = false;
this.selected = null;
this.selectedId = null;
this.episodes = [];
this.navigate('#podcasts', 'podcasts');
Alpine.store('library')._afterNavigation();
}
await this.load();
this.message = this.text(result.publication_pending ? 'pending' : 'done');
});
},
share(pod) {
if (
!pod.shared &&
!confirm(this.text('shareConfirm') + '\n' + pod.metadata.feed_url)
)
return;
this.task(async () => {
let result = await this.api('share', { id: pod.id, shared: !pod.shared });
if (result.confirmation_required) {
if (
!confirm(
this.text('privateConfirm') +
'\n' +
result.urls.filter(Boolean).join('\n'),
)
) {
this.message = '';
return;
}
result = await this.api('share', {
id: pod.id,
shared: true,
confirmed: true,
});
}
await this.load();
this.message = this.text(result.publication_pending ? 'pending' : 'done');
});
},
refresh(pod) {
this.task(async () => {
const data = await this.api('refresh', { id: pod.id });
await this.update();
this.message = this.text('checked') + data.added;
});
},
refreshAll() {
this.task(async () => {
let count = 0;
for (const pod of this.mine) {
const data = await this.api('refresh', { id: pod.id });
count += data.added;
}
await this.update();
this.message = this.text('checked') + count;
});
},
download(episode) {
this.task(async () => {
await this.api('download', { id: episode.id });
episode.downloading = true;
this.message = this.text('downloading');
});
},
search() {
const query = this.query.trim();
return this.task(async () => {
const data = await this.api('search', { query });
if (this.query.trim() !== query) {
this.message = '';
return;
}
this.hits = data.hits;
this.searched = true;
this.message = this.text('done');
});
},
resetSearch() {
this.searched = false;
this.hits = [];
},
publicCards() {
return [
...new Map(
(this.searched ? this.hits : this.public).map((p) => [p.id, p]),
).values(),
];
},
seasons() {
return [
...new Set(
this.episodes.map((e) => e.metadata.season).filter((s) => s != null),
),
].sort((a, b) => a - b);
},
filteredEpisodes() {
const filter = this.filter.toLocaleLowerCase();
return this.episodes.filter(
(e) =>
(!filter || e.metadata.title.toLocaleLowerCase().includes(filter)) &&
(!this.season || String(e.metadata.season) === String(this.season)) &&
(!this.unplayedOnly || !e.completed),
);
},
date(ms) {
return ms ? new Date(ms).toLocaleDateString() : '';
},
play(episode) {
return this.task(async () => {
const devices = Alpine.store('devices');
if (devices && !devices.isActive()) await devices.select(devices.id);
const position = episode.completed ? 0 : episode.position_ms;
const session = await this.api('progress', {
id: episode.id,
position_ms: position,
explicit: true,
});
const player = Alpine.store('player');
player._playLocal(
{
id: episode.id,
podcast: true,
podcast_generation: session.generation,
podcast_id: episode.metadata.podcast_id,
title: episode.metadata.title,
artists: [{ id: null, name: this.selected.metadata.title }],
featured_artists: [],
release_id: null,
release_title: this.selected.metadata.title,
duration_seconds: (episode.metadata.duration_ms || 0) / 1000,
stream_url: '/api/podcasts/media/' + encodeURIComponent(episode.id),
cover_url:
episode.metadata.image_url || this.selected.metadata.image_url,
},
{ position_seconds: position / 1000 },
);
this.lastCheckpoint = Date.now();
this.message = '';
});
},
checkpoint(player, completed = false, unloading = false) {
const track = player.currentTrack;
if (!track?.podcast) return;
const payload = {
action: 'progress',
id: track.id,
position_ms: Math.round((player.currentTime || 0) * 1000),
completed,
generation: track.podcast_generation,
sequence: Date.now(),
};
const episode = this.episodes.find((e) => e.id === track.id);
if (episode) {
episode.position_ms = payload.position_ms;
episode.completed = completed;
}
if (unloading) {
navigator.sendBeacon(
'/api/podcasts/action',
new Blob([JSON.stringify(payload)], { type: 'application/json' }),
);
} else {
this.api('progress', payload).catch(() => {});
}
this.lastCheckpoint = Date.now();
},
tick(player) {
if (
player.currentTrack?.podcast &&
player.isPlaying &&
Date.now() - this.lastCheckpoint > 10000
)
this.checkpoint(player, !!player.currentTrack.podcast_completed);
},
mark(episode) {
return this.task(async () => {
const completed = !episode.completed;
const position = completed ? episode.position_ms : 0;
const result = await this.api('progress', {
id: episode.id,
position_ms: position,
completed,
explicit: true,
});
episode.completed = completed;
episode.position_ms = position;
const player = Alpine.store('player');
if (player.currentTrack?.id === episode.id) {
player.currentTrack.podcast_generation = result.generation;
player.currentTrack.podcast_completed = completed;
if (!completed) player.seek(0);
}
this.message = this.text('done');
});
},
restart(episode) {
episode.position_ms = 0;
episode.completed = false;
return this.play(episode);
},
});
});
</script>
-15
View File
@@ -1,15 +0,0 @@
<button
type="button"
class="search-release-card podcast-tile"
@click="$store.podcasts.open(pod)"
:title="pod.metadata.title"
>
<div class="search-release-cover podcast-artwork">
{% include "player/podcast_artwork.html" %}
</div>
<div class="card-title" x-text="pod.metadata.title"></div>
<div
class="card-subtitle"
x-text="pod.metadata.author || $store.podcasts.text('podcasts')"
></div>
</button>
-39
View File
@@ -1,39 +0,0 @@
<style>
.podcast-nav { appearance:none; border:0; background:transparent; width:100%; font:inherit; text-align:left; }
.podcast-heading { display:flex; align-items:center; justify-content:space-between; gap:16px; flex-wrap:wrap; margin-bottom:20px; }
.podcast-heading .section-title, .podcast-heading .release-actions { margin:0; }
.podcast-section { margin-top:32px; }
.podcast-section-title { font-size:20px; font-weight:700; margin:0 0 16px; }
.podcast-tile { appearance:none; border:0; color:var(--text-primary); font:inherit; text-align:left; min-width:0; }
.podcast-tile:focus-visible { outline:2px solid var(--accent); outline-offset:3px; }
.podcast-tile .card-subtitle { white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
.podcast-artwork { color:var(--text-subdued); }
.podcast-artwork svg { width:48px; height:48px; }
.podcast-tile img { display:block; }
.search-release-cover.podcast-artwork svg { width:40px; height:40px; }
.podcast-detail-actions { display:contents; }
.podcast-toolbar { display:flex; align-items:center; flex-wrap:wrap; gap:12px; margin:16px 0; }
.podcast-toolbar input[type=text], .podcast-toolbar select { background:var(--bg-secondary); color:var(--text-primary); border:1px solid var(--border-color); border-radius:6px; padding:10px 12px; font:inherit; min-width:0; }
.podcast-toolbar input[type=text] { flex:1; min-width:160px; }
.podcast-toolbar label { display:flex; align-items:center; gap:8px; font-size:13px; color:var(--text-secondary); }
.podcast-toolbar input[type=checkbox] { accent-color:var(--accent); }
.podcast-notice { margin:12px 0; font-size:13px; color:var(--text-secondary); overflow-wrap:anywhere; }
.podcast-detail .release-meta { min-width:0; flex:1; }
.podcast-detail .release-title { overflow-wrap:anywhere; }
.podcast-description { margin:0 0 28px; max-width:80ch; color:var(--text-secondary); font-size:14px; line-height:1.7; white-space:pre-line; overflow-wrap:anywhere; }
.podcast-description-section { margin-bottom:28px; }
.podcast-description-section .podcast-description { margin:0; }
.podcast-description-section .artist-top-tracks-toggle { margin-top:8px; padding-left:0; }
.podcast-episode { padding:16px 0; border-bottom:1px solid var(--border-color); }
.podcast-episode h3 { font-size:14px; font-weight:500; margin:0 0 6px; overflow-wrap:anywhere; }
.podcast-episode > div { font-size:12px; color:var(--text-subdued); }
.podcast-episode details { margin-top:8px; font-size:12px; color:var(--text-secondary); }
.podcast-episode summary { cursor:pointer; width:fit-content; }
.podcast-episode .podcast-description { margin:8px 0 0; }
.podcast-detail .release-action-btn:disabled, .podcast-toolbar button:disabled { opacity:.5; cursor:default; }
@media(max-width:600px) {
.podcast-heading { align-items:flex-start; gap:12px; }
.podcast-heading .release-actions { gap:8px; }
.podcast-toolbar input[type=text], .podcast-toolbar select { font-size:16px; min-height:44px; }
}
</style>
-211
View File
@@ -1,211 +0,0 @@
<template x-if="$store.library.view === 'podcasts'">
<section>
<div class="podcast-heading">
<h1 class="section-title" x-text="$store.podcasts.text('podcasts')"></h1>
<div class="release-actions">
<button
class="release-action-btn secondary"
@click="$store.podcasts.refreshAll()"
:disabled="$store.podcasts.busy || $store.podcasts.loading"
x-text="$store.podcasts.text('checkAll')"
></button>
<button
class="release-action-btn primary"
@click="$store.podcasts.adding=!$store.podcasts.adding"
:aria-expanded="$store.podcasts.adding"
aria-controls="podcast-add-feed"
x-text="$store.podcasts.text('add')"
></button>
</div>
</div>
<form
id="podcast-add-feed"
class="podcast-toolbar"
x-show="$store.podcasts.adding"
x-cloak
@submit.prevent="$store.podcasts.add()"
>
<input
type="text"
x-model="$store.podcasts.url"
placeholder="RSS / Atom URL"
aria-label="RSS / Atom URL"
required
/>
<button
class="release-action-btn primary"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text('subscribe')"
></button>
</form>
<p
class="podcast-notice"
role="status"
aria-live="polite"
x-show="$store.podcasts.message"
x-text="$store.podcasts.message"
></p>
<h2 class="podcast-section-title" x-text="$store.podcasts.text('mine')"></h2>
<div
class="loading-spinner"
x-show="$store.podcasts.loading && !$store.podcasts.mine.length"
>
<div class="spinner"></div>
</div>
<div class="empty-state" x-show="!$store.podcasts.loading && !$store.podcasts.mine.length">
<p x-text="$store.podcasts.text('empty')"></p>
</div>
<div class="card-grid">
<template x-for="pod in $store.podcasts.mine" :key="pod.id"
>{% include "player/podcast_card.html" %}</template
>
</div>
<section class="podcast-section">
<h2
class="podcast-section-title"
x-text="$store.podcasts.text($store.podcasts.searched?'results':'public')"
></h2>
<form class="podcast-toolbar" @submit.prevent="$store.podcasts.search()">
<input
type="text"
x-model="$store.podcasts.query"
@input="$store.podcasts.resetSearch()"
:placeholder="$store.podcasts.text('searchNetwork')"
:aria-label="$store.podcasts.text('searchNetwork')"
minlength="2"
maxlength="200"
/>
<button
class="release-action-btn secondary"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text('search')"
></button>
</form>
<div
class="empty-state"
x-show="!$store.podcasts.loading && !$store.podcasts.publicCards().length"
>
<p
x-text="$store.podcasts.text($store.podcasts.searched?'noMatches':'noPublic')"
></p>
</div>
<div class="card-grid">
<template x-for="pod in $store.podcasts.publicCards()" :key="pod.id"
>{% include "player/podcast_card.html" %}</template
>
</div>
</section>
</section>
</template>
<template x-if="$store.library.view === 'podcast_detail'">
<section class="podcast-detail">
<div class="breadcrumb">
<a
href="#podcasts"
@click.prevent="$store.podcasts.enter()"
x-text="$store.podcasts.text('podcasts')"
></a
><span>/</span>
<span
x-text="$store.podcasts.selected?.metadata.title || $store.podcasts.text($store.podcasts.loading?'working':'notFound')"
></span>
</div>
<div class="loading-spinner" x-show="$store.podcasts.loading && !$store.podcasts.selected">
<div class="spinner"></div>
</div>
<p
class="podcast-notice"
role="status"
aria-live="polite"
x-show="$store.podcasts.message"
x-text="$store.podcasts.message"
></p>
<template
x-for="pod in ($store.podcasts.selected ? [$store.podcasts.selected] : [])"
:key="pod.id"
>
<div>
<div class="release-header">
<div class="release-cover podcast-artwork">
{% include "player/podcast_artwork.html" %}
</div>
<div class="release-meta">
<h1 class="release-title" x-text="pod.metadata.title"></h1>
<div class="release-artists" x-text="pod.metadata.author"></div>
<div class="artist-stats" x-show="pod.episodes != null">
<span
x-text="(pod.episodes || 0) + ' ' + $store.podcasts.text('episodes')"
></span
><span
x-show="pod.subscribed && pod.new_episodes"
x-text="' · ' + pod.new_episodes + ' ' + $store.podcasts.text('unplayed')"
></span>
</div>
<div class="release-actions">
<template x-if="!pod.subscribed"
><button
class="release-action-btn primary"
@click="$store.podcasts.subscribe(pod)"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text('subscribe')"
></button
></template>
<template x-if="pod.subscribed"
><div class="podcast-detail-actions">
<button
class="release-action-btn secondary"
@click="$store.podcasts.refresh(pod)"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text('check')"
></button>
<button
class="release-action-btn secondary"
@click="$store.podcasts.share(pod)"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text(pod.shared?'unpublish':'publish')"
></button>
<button
class="release-action-btn secondary"
@click="$store.podcasts.remove(pod)"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text('remove')"
></button></div
></template>
</div>
</div>
</div>
<div class="podcast-description-section" x-show="pod.metadata.description">
<p
id="podcast-description"
class="podcast-description"
x-text="$store.podcasts.description(pod)"
></p>
<button
class="artist-top-tracks-toggle"
x-show="(pod.metadata.description || '').length>360"
@click="$store.podcasts.descriptionExpanded=!$store.podcasts.descriptionExpanded"
:aria-expanded="$store.podcasts.descriptionExpanded"
aria-controls="podcast-description"
x-text="$store.podcasts.text($store.podcasts.descriptionExpanded?'showLess':'showMore')"
></button>
</div>
<p class="podcast-notice" x-show="pod.error" x-text="pod.error"></p>
<template x-if="pod.subscribed"
><section>
<div class="loading-spinner" x-show="$store.podcasts.loading">
<div class="spinner"></div>
</div>
<div x-show="!$store.podcasts.loading">
{% include "player/podcast_episodes.html" %}
</div>
</section></template
>
<p
class="podcast-notice"
x-show="!pod.subscribed"
x-text="$store.podcasts.text('subscribeHint')"
></p>
</div>
</template>
</section>
</template>
+315 -31
View File
@@ -64,6 +64,8 @@ const T = {
lastfmDisconnectFailed: "{{ t.player_lastfm_disconnect_failed }}",
download: "{{ t.track_download }}",
shareUnavailable: "{{ t.share_unavailable }}",
queuePodcastUnplayable: "{{ t.player_queue_podcast_unplayable }}",
queuePrivateItem: "{{ t.player_queue_private_item }}",
searchSimilarTo: "{{ t.player_search_similar_to }}",
findSimilar: "{{ t.player_find_similar }}",
similarityFailed: "{{ t.player_similarity_failed }}",
@@ -755,6 +757,9 @@ document.addEventListener('alpine:init', () => {
_listenedSeconds: 0,
_lastAudioTime: 0,
_localSourceTrackId: null,
// The current item is one this player cannot play and nobody told it
// that item's position (see _showUnplayableQueueItem).
_positionUnknown: false,
_remoteExecuting: false,
_remoteStateBaseTime: 0,
_remoteStateReceivedAt: 0,
@@ -772,21 +777,17 @@ 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;
Alpine.store('podcasts')?.tick(this);
this._trackListenedDelta();
this._maybePrefetchNext();
});
audio.addEventListener('ended', () => {
if (this.currentTrack?.podcast) {
this.isPlaying = false;
this.currentTrack.podcast_completed = true;
Alpine.store('podcasts')?.checkpoint(this, true);
return;
}
this._trackListenedDelta();
this._recordHistory('finished');
if (Alpine.store('devices')?.shouldPlayJamLocally()) {
@@ -803,7 +804,6 @@ document.addEventListener('alpine:init', () => {
this._sendNowPlaying();
});
audio.addEventListener('pause', () => {
if (this.currentTrack?.podcast) Alpine.store('podcasts')?.checkpoint(this, !!this.currentTrack.podcast_completed);
this._trackListenedDelta();
this.isPlaying = false;
this._lastAudioTime = audio.currentTime || 0;
@@ -865,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) {
@@ -888,11 +889,28 @@ 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);
},
_maybePrefetchNext() {
if (this.currentTrack?.podcast) return;
if (this.progress < 90 || !this.isPlaying) return;
const queue = Alpine.store('queue');
const nextIndex = queue?.currentIndex + 1;
@@ -909,8 +927,13 @@ document.addEventListener('alpine:init', () => {
},
_playLocal(track, options = {}) {
if (this.currentTrack?.podcast) Alpine.store('podcasts')?.checkpoint(this, !!this.currentTrack.podcast_completed);
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;
@@ -920,9 +943,6 @@ document.addEventListener('alpine:init', () => {
this._resetPlaybackTracking();
audio.src = track.stream_url;
const seekSeconds = Number(options.position_seconds || 0);
this.currentTime = seekSeconds;
this.duration = Number(track.duration_seconds || 0);
this.progress = this.duration > 0 ? seekSeconds / this.duration * 100 : 0;
if (seekSeconds > 0) {
const onLoaded = () => {
audio.currentTime = seekSeconds;
@@ -970,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(); }
@@ -993,6 +1035,11 @@ document.addEventListener('alpine:init', () => {
this._sendRemote('seek', { time: nextTime });
return;
}
if (this._isUnplayableQueueItem(this.currentTrack)) {
// Nothing is loaded in <audio>: the seek sets the item's position.
this._showUnplayableQueueItem(this.currentTrack, nextTime);
return;
}
audio.currentTime = nextTime;
this._lastAudioTime = audio.currentTime || 0;
},
@@ -1000,7 +1047,7 @@ document.addEventListener('alpine:init', () => {
seekRelative(delta) {
if (!this.currentTrack) return;
const duration = this.duration || audio.duration || 0;
const current = this._shouldSendRemote() ? this.currentTime : audio.currentTime;
const current = this._shouldSendRemote() || this._isUnplayableQueueItem(this.currentTrack) ? this.currentTime : audio.currentTime;
const max = duration > 0 ? duration : Number.MAX_SAFE_INTEGER;
this.seek(Math.max(0, Math.min(max, current + delta)));
},
@@ -1050,7 +1097,8 @@ document.addEventListener('alpine:init', () => {
this._recordHistory('skipped');
let nextIdx;
if (this.repeatMode === 'one') {
// Repeat "one" cannot repeat an item this player cannot play.
if (this.repeatMode === 'one' && !this._isUnplayableQueueItem(this.currentTrack)) {
this.seek(0);
this._historyRecorded = false;
this._resetPlaybackTracking();
@@ -1077,7 +1125,10 @@ document.addEventListener('alpine:init', () => {
this._sendRemote('prev');
return;
}
if (this.currentTime > 3) {
// An item this player cannot play is not playing here, so there
// is nothing to restart: Prev goes to the previous item.
const restartable = !this._isUnplayableQueueItem(this.currentTrack);
if (restartable && this.currentTime > 3) {
this.seek(0);
return;
}
@@ -1089,7 +1140,7 @@ document.addEventListener('alpine:init', () => {
if (this.repeatMode === 'all') {
prevIdx = queue.tracks.length - 1;
} else {
this.seek(0);
if (restartable) this.seek(0);
return;
}
}
@@ -1221,15 +1272,22 @@ document.addEventListener('alpine:init', () => {
},
_devicePlaybackStatePayload() {
if (this.currentTrack?.podcast) return null;
const queue = Alpine.store('queue');
const track = this.currentTrack || queue?.tracks?.[queue.currentIndex] || null;
if (!track && (!queue || queue.tracks.length === 0)) return null;
return this._remotePlaybackPayload(track, {
position_seconds: audio.currentTime || this.currentTime || 0,
// <audio> holds an older track while an unplayable item is current.
const position = this._currentItemHasLocalAudio(track)
? (audio.currentTime || this.currentTime || 0)
: (this.currentTime || 0);
const payload = this._remotePlaybackPayload(track, {
position_seconds: position,
duration_seconds: this._trackDuration(),
paused: !this.isPlaying,
});
// The server fills the episode's resume position from its progress
// register instead of handing 0 to the next device.
if (this._positionUnknown && !this._currentItemHasLocalAudio(track)) payload.position_unknown = true;
return payload;
},
_mirrorRemoteTrack(track, playing, positionSeconds = null) {
@@ -1290,6 +1348,11 @@ document.addEventListener('alpine:init', () => {
this._remoteStateBaseTime = desiredTime;
this._remoteStateReceivedAt = Date.now();
if (this._isUnplayableQueueItem(track)) {
this._showUnplayableQueueItem(track, state.position_unknown ? null : desiredTime);
this._updateMediaSession();
return;
}
if (this._localSourceTrackId !== track.id) {
this._playLocal(track, {
position_seconds: desiredTime,
@@ -1335,6 +1398,9 @@ document.addEventListener('alpine:init', () => {
if (!command || !command.command) return;
const payload = command.payload || {};
const queue = Alpine.store('queue');
// The server stamps Jam participant commands. It checks them against
// the host state it saw last; this queue is the one they change.
if (payload.jam_participant === true && !this._jamParticipantCommandAllowed(command.command, payload, queue)) return;
this._remoteExecuting = true;
try {
if (typeof payload.shuffle === 'boolean') this.shuffle = payload.shuffle;
@@ -1349,7 +1415,13 @@ document.addEventListener('alpine:init', () => {
const track = payload.track || queue.tracks[queue.currentIndex];
if (track?.unavailable || (track && !track.stream_url)) {
this._applyRemotePlaybackState({ ...payload, track, paused: true });
this._pauseLocal();
// This device is now active, so _applyRemotePlaybackState
// does not set the time: keep the handed-off position as
// the item's position and unload the previous audio.
// Play commands start an item from 0, which for an
// episode means "its resume position", unknown here.
const known = command.command === 'transfer_state' && payload.position_unknown !== true;
this._showUnplayableQueueItem(track, known ? payload.position_seconds : null);
} else if (track) {
this._playLocal(track, payload);
}
@@ -1400,13 +1472,168 @@ document.addEventListener('alpine:init', () => {
navigator.mediaSession.setActionHandler('seekto', (d) => { if (d.seekTime != null) this.seek(d.seekTime); });
},
_queueItemSourceKind(track) {
return track?.source?.kind || track?.wire_track?.source?.kind || 'music';
},
_isUnplayableQueueItem(track) {
const kind = this._queueItemSourceKind(track);
return kind === 'podcast_episode' || kind === 'private';
},
_unplayableQueueLabel(track) {
const kind = this._queueItemSourceKind(track);
if (kind === 'podcast_episode') return T.queuePodcastUnplayable;
if (kind === 'private') return T.queuePrivateItem;
return '';
},
_playableQueueIndex(tracks, start, step = 1) {
const count = Array.isArray(tracks) ? tracks.length : 0;
for (let index = start; index >= 0 && index < count; index += step) {
if (!this._isUnplayableQueueItem(tracks[index])) return index;
}
return -1;
},
_currentItemHasLocalAudio(track = this.currentTrack) {
// Whether <audio> can hold this item: podcast episodes, private
// items and unresolved federation items are never loaded.
return !!track && !track.unavailable && !!track.stream_url && !this._isUnplayableQueueItem(track);
},
_showUnplayableQueueItem(track, positionSeconds = null) {
// `positionSeconds` null: nobody told this player where the item
// was left (it only knows positions from handoffs and seeks).
this._positionUnknown = positionSeconds == null;
// Unload the previous source so a later play() cannot resume it.
audio.pause();
audio.removeAttribute('src');
audio.load();
this.isPlaying = false;
this.currentTrack = track;
this._historyTrack = null;
this._localSourceTrackId = track?.id ?? null;
this.duration = Number(track?.duration_seconds || 0);
// Keep the item's position (handoff, restore) so it is reported back unchanged.
let position = Math.max(0, Number(positionSeconds || 0));
if (!Number.isFinite(position)) position = 0;
if (this.duration > 0) position = Math.min(position, this.duration);
this.currentTime = position;
this._remoteStateBaseTime = position;
this._remoteStateReceivedAt = Date.now();
this.progress = this.duration > 0 ? (position / this.duration) * 100 : 0;
Alpine.store('queue')?.syncCurrentIndexToTrack(track);
},
_jamParticipantCommandAllowed(command, payload, queue) {
// Jam participants cannot remove, clear away, add or bring back the
// host's private items (podcast episodes). Commands run in a batch,
// so an index the server checked can name another item by now.
const tracks = queue?.tracks || [];
const isPrivate = track => this._isUnplayableQueueItem(track);
if (command === 'queue_remove') {
const index = Number(payload.index);
if (!Number.isInteger(index)) return !tracks.some(isPrivate);
return !isPrivate(tracks[index]);
}
if (command === 'queue_clear') return !tracks.some(isPrivate);
if (command === 'queue_add_end' || command === 'queue_add_next') {
return !(Array.isArray(payload.tracks) ? payload.tracks : []).some(isPrivate);
}
if (command === 'play_track' || command === 'play_from_index' || command === 'transfer_state') {
const incoming = Array.isArray(payload.tracks) ? payload.tracks.filter(Boolean) : [];
if (incoming.length === 0) return !isPrivate(payload.track);
// A full queue replaces this one: it must hold exactly the private
// items this queue holds now (none dropped, repeated or added).
const key = track => {
const source = track?.source || track?.wire_track?.source || {};
return `${source.kind || ''}:${source.episode_id || ''}`;
};
const counts = list => {
const result = new Map();
list.filter(isPrivate).forEach(track => result.set(key(track), (result.get(key(track)) || 0) + 1));
return result;
};
const mine = counts(tracks);
const theirs = counts(incoming);
return mine.size === theirs.size && [...theirs].every(([item, count]) => mine.get(item) === count);
}
return true;
},
_dropJamPlaceholders() {
// A Jam guest's queue shows the host's private items as placeholders.
// They stand for someone else's items and never become this user's
// own queue (persisted, relayed to their devices) after the Jam.
const queue = Alpine.store('queue');
if (!queue) return;
const isPlaceholder = track => this._queueItemSourceKind(track) === 'private';
const tracks = Array.isArray(queue.tracks) ? queue.tracks : [];
if (!tracks.some(isPlaceholder) && !isPlaceholder(this.currentTrack)) return;
const currentIndex = Math.max(0, Number(queue.currentIndex || 0));
const kept = tracks.filter(track => !isPlaceholder(track));
let index = kept.indexOf(tracks[currentIndex]);
// A removed current item is followed by the next item that stays.
if (index < 0) index = tracks.slice(0, currentIndex).filter(track => !isPlaceholder(track)).length;
queue.tracks = kept;
queue.currentIndex = Math.max(0, Math.min(index, kept.length - 1));
if (!isPlaceholder(this.currentTrack)) return;
const next = kept[queue.currentIndex] || null;
if (next) {
this._playLocal(next, { paused: true });
return;
}
this._pauseLocal();
audio.removeAttribute('src');
audio.load();
this.currentTrack = null;
this._historyTrack = null;
this._localSourceTrackId = null;
this._positionUnknown = false;
this.currentTime = 0;
this.duration = 0;
this.progress = 0;
},
_queueItemsPayload(tracks) {
// Library tracks by id; everything else verbatim with its source.
return (tracks || []).map(track => {
if (track?.wire_track) return { kind: 'external', track: track.wire_track };
const id = Number(track?.id);
if (Number.isInteger(id) && id > 0 && !track?.federation_pending) {
return { kind: 'library', track_id: id };
}
return null;
});
},
_restoredQueueTracks(items, libraryTracks) {
const byId = new Map((libraryTracks || []).map(track => [track.id, track]));
const tracks = [];
const positions = [];
(items || []).forEach((item, index) => {
const track = item?.kind === 'external' ? item.track : byId.get(item?.track_id);
if (!track) return;
positions[index] = tracks.length;
tracks.push(track);
});
return { tracks, positions };
},
_buildStatePayload() {
const queue = Alpine.store('queue');
const localQueue = queue.tracks.filter(track => Number.isInteger(Number(track.id)));
const currentLocalId = this.currentTrack && Number.isInteger(Number(this.currentTrack.id))
? Number(this.currentTrack.id)
: null;
const typedItems = this._queueItemsPayload(queue.tracks);
const currentItemIndex = Math.max(0, Math.min(Number(queue.currentIndex || 0), queue.tracks.length - 1));
const queueItems = typedItems.filter(Boolean);
const queueItemsPosition = typedItems.slice(0, currentItemIndex).filter(Boolean).length;
return {
queue_items: queueItems,
queue_items_position: queueItemsPosition,
current_track_id: currentLocalId,
position_ms: Math.floor(this.currentTime * 1000),
queue: localQueue.map(track => Number(track.id)),
@@ -1420,7 +1647,6 @@ document.addEventListener('alpine:init', () => {
},
_saveState() {
if (this.currentTrack?.podcast) { Alpine.store('podcasts')?.checkpoint(this, !!this.currentTrack.podcast_completed); return; }
if (GUEST) return;
const queue = Alpine.store('queue');
if (!this.currentTrack && queue.tracks.length === 0) return;
@@ -1433,7 +1659,6 @@ document.addEventListener('alpine:init', () => {
},
_saveStateSync() {
if (this.currentTrack?.podcast) { Alpine.store('podcasts')?.checkpoint(this, !!this.currentTrack.podcast_completed, true); return; }
if (GUEST) return;
const queue = Alpine.store('queue');
if (!this.currentTrack && queue.tracks.length === 0) return;
@@ -1452,6 +1677,56 @@ document.addEventListener('alpine:init', () => {
this.repeatMode = state.repeat_mode || 'off';
this._setVolumeLocal(typeof state.volume === 'number' ? state.volume : 0.7);
// Typed queue: library tracks by id plus external items
// (podcast episodes and other items kept with their source).
if (Array.isArray(state.queue_items) && state.queue_items.length > 0) {
try {
const ids = state.queue_items.filter(item => item?.kind === 'library').map(item => item.track_id);
let libraryTracks = [];
if (ids.length > 0) {
const tracksRes = await fetch('/api/player/tracks-by-ids', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ ids }),
});
if (tracksRes.ok) libraryTracks = await tracksRes.json();
}
const restored = this._restoredQueueTracks(state.queue_items, libraryTracks);
if (restored.tracks.length > 0) {
const queue = Alpine.store('queue');
queue.tracks = restored.tracks;
const wanted = Number(state.queue_items_position || 0);
let idx = restored.positions[wanted];
if (idx == null) idx = restored.positions.slice(wanted).find(value => value != null);
if (idx == null) idx = restored.tracks.length - 1;
queue.currentIndex = idx;
const currentTrack = restored.tracks[idx];
if (this._isUnplayableQueueItem(currentTrack)) {
// A saved 0 is treated as unknown: the server then
// uses the episode's progress register.
this._showUnplayableQueueItem(currentTrack, state.position_ms ? state.position_ms / 1000 : null);
} else if (currentTrack) {
this.currentTrack = currentTrack;
this._historyTrack = currentTrack;
this._localSourceTrackId = currentTrack.id;
this._historyRecorded = false;
this._resetPlaybackTracking();
audio.src = currentTrack.stream_url;
const seekMs = state.position_ms || 0;
if (seekMs > 0) {
const onLoaded = () => {
audio.currentTime = seekMs / 1000;
audio.removeEventListener('loadedmetadata', onLoaded);
};
audio.addEventListener('loadedmetadata', onLoaded);
}
this._updateMediaSession();
}
return;
}
} catch {}
}
// Restore queue if there are track IDs
if (state.queue && state.queue.length > 0) {
try {
@@ -1621,6 +1896,7 @@ document.addEventListener('alpine:init', () => {
fedInviteInput: '',
fedBusy: false,
fedError: '',
selectError: '',
remoteHintVisible: false,
remoteHintDeviceName: '',
_remoteHintShown: false,
@@ -1716,6 +1992,7 @@ document.addEventListener('alpine:init', () => {
_apply(data) {
const previousJamId = this.currentJamId;
const wasControllingJam = this.isControllingRemoteJam();
this.activeDeviceId = data.active_device_id || null;
this.devices = Array.isArray(data.devices) ? data.devices : [];
this.jams = Array.isArray(data.jams) ? data.jams : [];
@@ -1733,6 +2010,9 @@ document.addEventListener('alpine:init', () => {
if (!this.isActive() && !this.shouldPlayJamLocally()) {
Alpine.store('player')?._pauseLocal();
}
if (wasControllingJam && !this.isControllingRemoteJam()) {
Alpine.store('player')?._dropJamPlaceholders();
}
this._maybeShowRemoteHint();
},
@@ -2024,7 +2304,12 @@ document.addEventListener('alpine:init', () => {
current_device_id: this.id,
}),
});
if (!res.ok) return;
if (!res.ok) {
// For example: the target device needs an update to receive podcast episodes.
this.selectError = res.status === 409 ? await this._errorText(res) : '';
return;
}
this.selectError = '';
const data = await res.json();
this._apply(data);
this.open = false;
@@ -2228,11 +2513,13 @@ document.addEventListener('alpine:init', () => {
},
clearJamSelection() {
const wasControllingJam = this.isControllingRemoteJam();
this.currentJamId = null;
this.jamPanelOpen = false;
this.jamPanelJamId = null;
this._setJamLocalPlayback(false, { pauseLocal: true });
sessionStorage.removeItem('furu_player_jam_id');
if (wasControllingJam) Alpine.store('player')?._dropJamPlaceholders();
},
});
@@ -2346,7 +2633,10 @@ document.addEventListener('alpine:init', () => {
playFromIndex(idx) {
if (idx < 0 || idx >= this.tracks.length) return;
Alpine.store('player').playQueueIndex(idx);
const player = Alpine.store('player');
// A device playing the audio elsewhere may support the item.
if (player._isUnplayableQueueItem(this.tracks[idx]) && !player._shouldSendRemote()) return;
player.playQueueIndex(idx);
},
remove(idx) {
@@ -2669,12 +2959,6 @@ document.addEventListener('alpine:init', () => {
if (view === 'artists' && !id) {
if (this.view !== 'artists' || this.artistsPage === 0) this.goArtists(options);
else if (options.restoreScroll) this._restoreScrollPosition(hash);
} else if (view === 'podcasts') {
Alpine.store('podcasts').enter(options);
} else if (view === 'podcast') {
const podcastId = new URLSearchParams(params).get('id');
if(podcastId)Alpine.store('podcasts').open(podcastId,options);
else Alpine.store('podcasts').enter(options);
} else if (view === 'uploads' && !id) {
if (this.view !== 'my_uploads' || this.artistsPage === 0) this.goMyUploads(options);
else if (options.restoreScroll) this._restoreScrollPosition(hash);
+10 -15
View File
@@ -75,7 +75,6 @@
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><path d="M17 8l-5-5-5 5"/><path d="M12 3v12"/></svg>
{{ t.player_my_uploads }}
</div>
<button class="sidebar-nav-item podcast-nav" :class="{active:['podcasts','podcast_detail'].includes($store.library.view)}" @click="$store.podcasts.enter()"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="2" width="6" height="13" rx="3"/><path d="M5 10v2a7 7 0 0014 0v-2M12 19v3M8 22h8"/></svg><span x-text="$store.podcasts.text('podcasts')"></span></button>
</div>
<div class="sidebar-section">
<div class="sidebar-section-title">
@@ -188,7 +187,6 @@
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><path d="M17 8l-5-5-5 5"/><path d="M12 3v12"/></svg>
{{ t.player_my_uploads }}
</div>
<button class="sidebar-nav-item podcast-nav" :class="{active:['podcasts','podcast_detail'].includes($store.library.view)}" @click="$store.podcasts.enter()"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="2" width="6" height="13" rx="3"/><path d="M5 10v2a7 7 0 0014 0v-2M12 19v3M8 22h8"/></svg><span x-text="$store.podcasts.text('podcasts')"></span></button>
</div>
<div class="mobile-drawer-section">
@@ -409,7 +407,6 @@
</div>
<!-- Search Results -->
{% include "player/podcasts.html" %}
<template x-if="$store.library.view === 'search'">
<div>
<div class="search-similarity-heading"
@@ -440,7 +437,7 @@
</template>
<template x-if="!$store.library.searchLoading && $store.library.searchResults">
<div :class="{ 'similarity-unified-results': $store.library.similaritySearchLabel }">
<template x-if="!$store.library.similaritySearchError && $store.library.searchResults.artists.length === 0 && $store.library.searchResults.releases.length === 0 && $store.library.searchResults.tracks.length === 0 && !($store.library.searchResults.podcasts || []).length">
<template x-if="!$store.library.similaritySearchError && $store.library.searchResults.artists.length === 0 && $store.library.searchResults.releases.length === 0 && $store.library.searchResults.tracks.length === 0">
<div class="empty-state">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>
<p>{{ t.player_no_results }}</p>
@@ -551,16 +548,6 @@
</template>
</div>
</template>
<template x-if="($store.library.searchResults.podcasts || []).length">
<section class="search-section">
<h2 class="search-section-title" x-text="$store.podcasts.text('podcasts')"></h2>
<div class="search-releases-row">
<template x-for="pod in $store.library.searchResults.podcasts" :key="pod.id">
{% include "player/podcast_search_card.html" %}
</template>
</div>
</section>
</template>
<div class="search-section federation-search-section"
:class="{ 'similarity-federation-merged': $store.library.similaritySearchLabel }">
<h2 class="search-section-title" x-show="!$store.library.similaritySearchLabel">
@@ -1534,7 +1521,8 @@
<template x-for="item in $store.queue.displayItems()" :key="item.key">
<div class="queue-track"
:data-queue-index="item.index"
:class="{ active: item.state === 'current', current: item.state === 'current', played: item.state === 'played', dragging: $store.queue._dragIdx === item.index, synthetic: item.synthetic, 'foreign-jam-track': $store.queue.isForeignJamTrack(item.track) }"
:class="{ active: item.state === 'current', current: item.state === 'current', played: item.state === 'played', dragging: $store.queue._dragIdx === item.index, synthetic: item.synthetic, 'foreign-jam-track': $store.queue.isForeignJamTrack(item.track), unplayable: $store.player._isUnplayableQueueItem(item.track) }"
:title="$store.player._unplayableQueueLabel(item.track) || null"
:style="$store.queue.isForeignJamTrack(item.track) ? $store.queue.contributorStyle(item.track) : ''"
@click="item.index >= 0 ? $store.queue.playFromIndex(item.index) : $store.player.play(item.track)"
:draggable="!item.synthetic"
@@ -1587,6 +1575,10 @@
</div>
<div class="queue-track-info">
<div class="queue-track-title" x-text="item.track.title"></div>
<div class="queue-track-unplayable"
x-show="$store.player._isUnplayableQueueItem(item.track)"
x-cloak
x-text="$store.player._unplayableQueueLabel(item.track)"></div>
<div class="queue-track-artist">
<template x-for="(artist, artistIdx) in $store.library.trackArtistLinks(item.track)" :key="artist.label + '-' + artist.id + '-' + artistIdx">
<span>
@@ -1813,6 +1805,9 @@
<span>Trusted federation devices</span>
</div>
</template>
<template x-if="$store.devices.selectError">
<div class="fed-device-error device-select-error" role="alert" x-text="$store.devices.selectError"></div>
</template>
<template x-for="device in $store.devices.playbackFedDevices()" :key="device.id">
<button data-member-only class="device-row federation-device-row"
:class="{ active: device.is_active }"
+15
View File
@@ -1440,6 +1440,17 @@ button.user-stat:hover {
.queue-track.current .queue-track-title { color: var(--accent); }
.queue-track.played .queue-track-title { color: var(--text-subdued); }
.queue-track.unplayable .queue-track-title,
.queue-track.unplayable .queue-track-cover { opacity: 0.55; }
.queue-track-unplayable {
font-size: 11px;
color: var(--text-subdued);
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.queue-track-artist {
font-size: 11px;
color: var(--text-subdued);
@@ -2065,6 +2076,10 @@ button.user-stat:hover {
color: #ffb2b2;
}
.device-select-error {
padding: 6px 12px;
}
.fed-device-row {
min-height: 32px;
display: grid;
-85
View File
@@ -1,85 +0,0 @@
// Render first: FURU_PODCAST_RENDER_FIXTURE=1 cargo test renders_podcast_navigation_and_views
// Uses the real rendered application with isolated API/feed fixtures; no user data.
const {chromium}=require(process.env.PLAYWRIGHT_MODULE||'playwright');
const fs=require('node:fs'),path=require('node:path'),assert=require('node:assert/strict');
const root=path.resolve(__dirname,'..');
const html=fs.readFileSync(path.join(root,'target/podcast-player-fixture.html'),'utf8');
const alpinePath=process.env.ALPINE_FIXTURE||path.join(root,'target/podcast-alpine.min.js');
const cover='https://feeds.example.test/cover.svg';
const description='A long RSS description, shown only on the detail page. '.repeat(150);
const mine=[
{id:'pod1:own',metadata:{title:'A podcast about sound',author:'Sound studio',description,image_url:cover},episodes:2,new_episodes:1,shared:false},
{id:'pod1:broken',metadata:{title:'A missing cover',author:'Test publisher',image_url:'https://feeds.example.test/missing.jpg'},episodes:0,new_episodes:0,shared:false},
{id:'pod1:none',metadata:{title:'No RSS artwork',author:null},episodes:0,new_episodes:0,shared:false},
];
const publicPod={id:'pod1:public',url:'https://feeds.example.test/public.xml',metadata:{title:'Public podcast',author:'Another publisher',description,image_url:cover},subscribed:false};
const episode={id:'ep1:one',metadata:{title:'First episode',podcast_id:'pod1:own',published_at_ms:1700000000000,duration_ms:60000},cached:false,downloading:false,position_ms:0,completed:false,error:null};
(async()=>{
const browser=await chromium.launch({headless:true,...(process.env.CHROME_PATH?{executablePath:process.env.CHROME_PATH}:{})});
try{
const page=await browser.newPage({viewport:{width:1440,height:1000}}),errors=[],actions=[];
page.on('pageerror',error=>errors.push(error.message));
await page.route('**/*',async route=>{
const url=new URL(route.request().url());
if(url.hostname==='cdn.jsdelivr.net'&&url.pathname.includes('alpine')&&fs.existsSync(alpinePath))return route.fulfill({contentType:'application/javascript',body:fs.readFileSync(alpinePath,'utf8')});
if(url.hostname==='feeds.example.test')return url.pathname==='/cover.svg'?route.fulfill({contentType:'image/svg+xml',body:'<svg xmlns="http://www.w3.org/2000/svg" width="400" height="400"><rect width="400" height="400" fill="#244d43"/><circle cx="200" cy="175" r="85" fill="#d8ba78"/><text x="200" y="315" text-anchor="middle" fill="white" font-family="sans-serif" font-size="32">SOUND</text></svg>'}):route.fulfill({status:404,body:''});
if(url.hostname==='podcast-ui.test'&&url.pathname==='/')return route.fulfill({contentType:'text/html',body:html});
if(url.pathname==='/api/podcasts/action'){
const body=route.request().postDataJSON();actions.push(body);
if(body.action==='list')return route.fulfill({json:{mine,public:[publicPod]}});
if(body.action==='episodes')return route.fulfill({json:{episodes:[{...episode,metadata:{...episode.metadata,podcast_id:body.id}}],has_more:false}});
if(body.action==='add'){mine.push({...publicPod,episodes:1,new_episodes:1,shared:false});publicPod.subscribed=true;return route.fulfill({json:{ok:true,id:publicPod.id}});}
return route.fulfill({json:{ok:true}});
}
if(url.pathname==='/api/player/search')return route.fulfill({json:{artists:[{id:1,name:'A musician',image_url:cover,release_count:1,track_count:1}],releases:[],tracks:[],podcasts:[publicPod,mine[0]]}});
if(url.pathname.startsWith('/api/'))return route.fulfill({json:[]});
if(url.hostname==='cdn.jsdelivr.net')return route.continue();
return route.fulfill({status:404,body:''});
});
const settled=async view=>{await page.waitForFunction(v=>window.Alpine?.store('library')?.view===v&&!Alpine.store('podcasts').loading,view);};
await page.goto('http://podcast-ui.test/#podcasts');await settled('podcasts');
assert.equal(await page.locator('.card-grid .podcast-tile').count(),4);
assert.equal(await page.locator('.podcast-description').count(),0);
await page.waitForFunction(()=>document.querySelector('.podcast-tile img')?.naturalWidth>0);
await page.waitForFunction(()=>Alpine.store('podcasts').failedArtwork['https://feeds.example.test/missing.jpg']);
assert.equal(await page.locator('.podcast-tile[title="A missing cover"] svg').count(),1);
await page.screenshot({path:path.join(root,'target/podcast-ui-grid.png')});
await page.locator('.podcast-tile[title="A podcast about sound"]').click();await settled('podcast_detail');
assert.ok(page.url().endsWith('#podcast?id=pod1%3Aown'));
await page.getByRole('heading',{name:'First episode',exact:true}).waitFor();
assert.equal(await page.locator('.podcast-detail > template').count(),1);
assert.ok((await page.locator('.podcast-detail .podcast-description').first().innerText()).length<400);
await page.screenshot({path:path.join(root,'target/podcast-ui-detail.png')});
await page.getByRole('button',{name:'Show more',exact:true}).click();
assert.equal(await page.locator('.podcast-detail .podcast-description').first().innerText(),description.trim());
await page.getByRole('button',{name:'Show less',exact:true}).click();
await page.reload();await settled('podcast_detail');
await page.getByRole('heading',{name:'First episode',exact:true}).waitFor();
await page.goBack();await settled('podcasts');
await page.locator('.podcast-tile[title="Public podcast"]').click();await settled('podcast_detail');
assert.equal(actions.filter(a=>a.action==='add').length,0);
await page.getByRole('button',{name:'Subscribe',exact:true}).click();
await page.getByRole('button',{name:'Publish',exact:true}).waitFor();
assert.equal(actions.filter(a=>a.action==='add').length,1);
await page.evaluate(()=>Alpine.store('library').search('sound'));
await page.locator('.search-release-card.podcast-tile').first().waitFor();
const headings=await page.locator('.search-section-title').allTextContents();
assert.ok(headings.indexOf('Artists')<headings.indexOf('Podcasts'));
assert.equal(await page.locator('.search-section .podcast-description').count(),0);
const size=await page.locator('.search-release-card.podcast-tile').first().boundingBox();assert.ok(size.height<240&&size.width<=150);
await page.screenshot({path:path.join(root,'target/podcast-ui-search.png')});
await page.setViewportSize({width:390,height:844});
await page.goto('http://podcast-ui.test/#podcasts');await settled('podcasts');
await page.screenshot({path:path.join(root,'target/podcast-ui-mobile.png')});
await page.locator('.podcast-tile[title="A podcast about sound"]').click();await settled('podcast_detail');
assert.equal(await page.evaluate(()=>document.documentElement.scrollWidth>innerWidth),false);
await page.screenshot({path:path.join(root,'target/podcast-ui-mobile-detail.png')});
assert.deepEqual(errors,[]);
console.log('PASS: cold list/detail hashes, back navigation, RSS artwork/fallbacks, explicit subscribe, compact ordered search, desktop/mobile');
} finally {await browser.close();}
})().catch(error=>{console.error(error);process.exitCode=1;});
+377
View File
@@ -0,0 +1,377 @@
const assert = require('node:assert/strict');
const {readFileSync} = require('node:fs');
const {test} = require('node:test');
const vm = require('node:vm');
const template = readFileSync(`${__dirname}/../templates/player/scripts.html`, 'utf8');
// Queue items received from trusted devices that this player cannot play.
const podcast = {
id: -11, title: 'Episode 42', unavailable: true, stream_url: '',
source: {kind: 'podcast_episode', episode_id: 'ep1:x'},
wire_track: {id: 0, title: 'Episode 42', source: {kind: 'podcast_episode', episode_id: 'ep1:x'}},
};
const privateItem = {
id: -12, title: 'Private item', unavailable: true, stream_url: '',
source: {kind: 'private'}, wire_track: {id: 0, title: 'Private item', source: {kind: 'private'}},
};
const remoteMusic = {id: -13, title: 'Remote', unavailable: true, stream_url: '', wire_track: {id: 4, title: 'Remote'}};
const song = id => ({id, title: `Song ${id}`, stream_url: `/api/player/stream/${id}`});
function player(queue) {
// Exercise the production methods with audio and store stubs.
const methods = template.slice(
template.indexOf(' _queueItemSourceKind(track)'),
template.indexOf(' _saveState()'),
);
const audio = {paused: false, src: 'old', pause() { this.paused = true; }, removeAttribute(name) { if (name === 'src') this.src = ''; }, load() {}};
const stores = {queue: Object.assign({syncCurrentIndexToTrack() {}}, queue)};
const context = vm.createContext({
audio, T: {queuePodcastUnplayable: 'Podcast · not playable', queuePrivateItem: 'Private item · hidden'},
Alpine: {store: name => stores[name]},
});
vm.runInContext('this.methods = {' + methods + '};', context);
return Object.assign(context.methods, {audio, currentTrack: null, currentTime: 0, volume: 0.5, shuffle: false, repeatMode: 'off'});
}
test('podcast and private items are labelled and never played locally', () => {
const p = player({tracks: [], currentIndex: 0});
assert.equal(p._isUnplayableQueueItem(podcast), true);
assert.equal(p._isUnplayableQueueItem(privateItem), true);
assert.equal(p._isUnplayableQueueItem(remoteMusic), false);
assert.equal(p._isUnplayableQueueItem(song(1)), false);
assert.equal(p._unplayableQueueLabel(podcast), 'Podcast · not playable');
assert.equal(p._unplayableQueueLabel(privateItem), 'Private item · hidden');
assert.equal(p._unplayableQueueLabel(song(1)), '');
// A browser item that only carries the verbatim wire item is recognised too.
assert.equal(p._isUnplayableQueueItem({id: -1, wire_track: podcast.wire_track}), true);
});
test('skipping finds the next playable item in the direction of travel', () => {
const p = player({tracks: [], currentIndex: 0});
const tracks = [song(1), podcast, privateItem, song(2)];
assert.equal(p._playableQueueIndex(tracks, 1, 1), 3);
assert.equal(p._playableQueueIndex(tracks, 2, -1), 0);
assert.equal(p._playableQueueIndex([podcast], 0, 1), -1);
});
test('showing an unplayable item stops and unloads the previous audio', () => {
const p = player({tracks: [podcast], currentIndex: 0});
p.isPlaying = true;
p._showUnplayableQueueItem(podcast);
assert.equal(p.audio.paused, true);
assert.equal(p.audio.src, '');
assert.equal(p.isPlaying, false);
assert.equal(p.currentTrack, podcast);
assert.equal(p._historyTrack, null);
});
test('persisted queue keeps external items verbatim and in order', () => {
const tracks = [song(1), podcast, remoteMusic, {id: 'pending', federation_pending: true}, song(2)];
const p = player({tracks, currentIndex: 4});
p.currentTrack = tracks[4];
p.currentTime = 12.3;
const state = p._buildStatePayload();
assert.deepEqual(JSON.parse(JSON.stringify(state.queue_items)), [
{kind: 'library', track_id: 1},
{kind: 'external', track: podcast.wire_track},
{kind: 'external', track: remoteMusic.wire_track},
{kind: 'library', track_id: 2},
]);
// The pending federation entry is not persisted, as before.
assert.equal(state.queue_items_position, 3);
// The legacy id list is unchanged for rollback.
assert.deepEqual(JSON.parse(JSON.stringify(state.queue)), [1, -11, -13, 2]);
assert.equal(state.current_track_id, 2);
});
test('restoring merges library tracks and external items', () => {
const p = player({tracks: [], currentIndex: 0});
const restored = p._restoredQueueTracks([
{kind: 'library', track_id: 1},
{kind: 'external', track: podcast},
{kind: 'library', track_id: 99},
{kind: 'library', track_id: 2},
], [song(2), song(1)]);
assert.deepEqual(Array.from(restored.tracks, track => track.id), [1, -11, 2]);
assert.equal(restored.positions[3], 2);
assert.equal(restored.positions[2], undefined);
});
// Production methods by name, for flows that span several of them.
function method(name) {
const start = template.indexOf(`\n ${name}(`);
assert.ok(start >= 0, `method ${name} not found`);
const end = template.indexOf('\n },\n', start);
return template.slice(start + 1, end + 11);
}
function activePlayer(queueTracks, currentIndex, audioState = {}, options = {}) {
// The browser as the active (local) playback device.
const names = [
'_executeRemoteCommand', '_applyRemotePlaybackState', '_tickRemoteProgress',
'_devicePlaybackStatePayload', '_remotePlaybackPayload', '_trackDuration',
'_pauseLocal', '_playLocal', 'resume', 'next', 'prev', 'playQueueIndex', 'seek',
'_skipUnplayableCurrentItem', '_knownPosition', '_currentItemHasLocalAudio',
'_showUnplayableQueueItem', '_syncLocalPlaybackState',
'_queueItemSourceKind', '_isUnplayableQueueItem', '_playableQueueIndex',
'_jamParticipantCommandAllowed', '_dropJamPlaceholders',
];
const audio = Object.assign({
paused: true, currentTime: 0, duration: NaN, src: '',
played: [],
pause() { this.paused = true; },
play() { this.paused = false; this.played.push(this.src); return Promise.resolve(); },
removeAttribute(name) { if (name === 'src') this.src = ''; },
load() { this.currentTime = 0; },
addEventListener() {}, removeEventListener() {},
}, audioState);
const queue = {
tracks: queueTracks, currentIndex,
_tracksWithJamDefaults: tracks => tracks,
syncCurrentIndexToTrack(track) {
const index = this.tracks.indexOf(track);
if (index >= 0) this.currentIndex = index;
},
// Simplified local queue edits, as the host applies remote commands.
_removeLocal(index) { if (index >= 0 && index < this.tracks.length) this.tracks.splice(index, 1); },
_moveTrackLocal(from, to) { this.tracks.splice(to, 0, this.tracks.splice(from, 1)[0]); },
_clearLocal() { this.tracks = []; },
_addToEndLocal(tracks) { this.tracks.push(...tracks); },
};
const stores = {queue, devices: {heartbeat() {}}};
const context = vm.createContext({audio, Alpine: {store: name => stores[name]}});
if (options.random != null) vm.runInContext(`Math.random = () => ${options.random};`, context);
vm.runInContext('this.methods = {' + names.map(method).join('\n') + '};', context);
return Object.assign(context.methods, {
audio, queue,
currentTrack: queueTracks[currentIndex] || null, currentTime: 0, duration: 0, progress: 0,
isPlaying: false, shuffle: false, repeatMode: 'off', volume: 0.5,
_remoteStateBaseTime: 0, _remoteStateReceivedAt: 0,
_isLocalPlaybackDevice: () => true, _shouldSendRemote: () => false,
_shouldMirrorRemoteLocally: () => false,
_setVolumeLocal(v) { this.volume = v; }, _updateMediaSession() {}, _saveState() {},
_recordHistory() {}, _resetPlaybackTracking() {}, _mirrorRemoteTrack() {},
});
}
const episode = Object.assign({}, podcast, {duration_seconds: 1800});
test('handoff of a podcast episode keeps its position for the next handoff', () => {
for (const audioTime of [95, 0]) {
// <audio> still holds a music track (95 s) or the page is fresh (0 s).
const p = activePlayer([song(1)], 0, {currentTime: audioTime, src: '/api/player/stream/1'});
p._executeRemoteCommand({command: 'transfer_state', payload: {
tracks: [song(1), episode], index: 1, track: episode,
position_seconds: 1200, duration_seconds: 1800, paused: false,
}});
assert.equal(p.currentTrack, episode);
assert.equal(p.currentTime, 1200);
assert.equal(p.isPlaying, false);
assert.equal(p.audio.src, '', 'the previous track is unloaded');
const reported = p._devicePlaybackStatePayload();
assert.equal(reported.position_seconds, 1200);
assert.equal(reported.position_unknown, undefined, 'a handed-off position is known');
assert.equal(reported.index, 1);
assert.equal(reported.paused, true);
}
});
test('library tracks still report the audio position', () => {
const p = activePlayer([song(1)], 0, {currentTime: 42, src: '/api/player/stream/1'});
p.currentTime = 40;
assert.equal(p._devicePlaybackStatePayload().position_seconds, 42);
});
test('resume on an unplayable item skips it, also with repeat one', () => {
for (const repeatMode of ['one', 'off', 'all']) {
const p = activePlayer([podcast], 0);
p.repeatMode = repeatMode;
p.currentTime = 30;
p.resume();
p.next();
assert.equal(p.currentTrack, podcast);
assert.equal(p.isPlaying, false);
assert.equal(p.currentTime, 30, 'the item keeps its position');
assert.deepEqual(p.audio.played, []);
}
const p = activePlayer([song(1), podcast, song(2)], 1);
p.repeatMode = 'one';
p.resume();
assert.equal(p.currentTrack.id, 2);
assert.deepEqual(p.audio.played, ['/api/player/stream/2']);
// Repeat all wraps around to the first playable item.
const wrap = activePlayer([song(1), podcast], 1);
wrap.repeatMode = 'all';
wrap.resume();
assert.equal(wrap.currentTrack.id, 1);
});
test('an episode reached without its position reports it as unknown, never as 0', () => {
// Next from the last music track lands on a trailing episode.
const p = activePlayer([song(1), episode], 0, {currentTime: 200, src: '/api/player/stream/1'});
p.isPlaying = true;
p.currentTime = 200;
p.next();
assert.equal(p.currentTrack, episode);
assert.equal(p.isPlaying, false);
let reported = p._devicePlaybackStatePayload();
assert.equal(reported.index, 1);
assert.equal(reported.position_unknown, true);
// Still unknown after Play finds nothing to skip to.
p.resume();
assert.equal(p._devicePlaybackStatePayload().position_unknown, true);
// A seek is an explicit position.
p.seek(600);
reported = p._devicePlaybackStatePayload();
assert.equal(reported.position_seconds, 600);
assert.equal(reported.position_unknown, undefined);
// Music never reports the flag.
p.playQueueIndex(0);
assert.equal(p.currentTrack.id, 1);
assert.equal(p._devicePlaybackStatePayload().position_unknown, undefined);
// Another browser or a Jam guest plays the episode row (position 0 sent).
const remote = activePlayer([song(1), episode], 0, {currentTime: 30, src: '/api/player/stream/1'});
remote._executeRemoteCommand({command: 'play_from_index', payload: {
tracks: [song(1), episode], index: 1, track: episode, position_seconds: 0, paused: false,
}});
assert.equal(remote.currentTrack, episode);
assert.equal(remote._devicePlaybackStatePayload().position_unknown, true);
// A transfer passes on what the previous device did not know.
const relay = activePlayer([song(1)], 0);
relay._executeRemoteCommand({command: 'transfer_state', payload: {
tracks: [song(1), episode], index: 1, track: episode, position_seconds: 0,
position_unknown: true, paused: true,
}});
assert.equal(relay._devicePlaybackStatePayload().position_unknown, true);
// A mirrored state with a known position keeps it.
const mirror = activePlayer([song(1), episode], 0);
mirror._syncLocalPlaybackState({tracks: [song(1), episode], index: 1, track: episode, position_seconds: 900, paused: true});
assert.equal(mirror._devicePlaybackStatePayload().position_seconds, 900);
assert.equal(mirror._devicePlaybackStatePayload().position_unknown, undefined);
});
test('repeat all and shuffle continue past a trailing unplayable item', () => {
const wrap = activePlayer([song(1), episode], 0, {currentTime: 200, src: '/api/player/stream/1'});
wrap.repeatMode = 'all';
wrap.isPlaying = true;
wrap.next();
assert.equal(wrap.currentTrack.id, 1);
assert.equal(wrap.queue.currentIndex, 0);
assert.deepEqual(wrap.audio.played, ['/api/player/stream/1']);
// Shuffle picks the episode (index 1 of 3) and continues with music
// (searching towards the pick from the current item).
const shuffled = activePlayer([song(1), episode, song(2)], 2, {src: '/api/player/stream/2'}, {random: 0.5});
shuffled.shuffle = true;
shuffled.next();
assert.equal(shuffled.currentTrack.id, 1);
assert.equal(shuffled.isPlaying, false, 'the stub audio does not fire play events');
assert.deepEqual(shuffled.audio.played, ['/api/player/stream/1']);
// A trailing episode picked by shuffle wraps to the first playable item.
const trailing = activePlayer([song(1), song(2), episode], 1, {src: '/api/player/stream/2'}, {random: 0.9});
trailing.shuffle = true;
trailing.next();
assert.equal(trailing.currentTrack.id, 1);
// Without repeat the queue ends on the episode, as before.
const stop = activePlayer([song(1), episode], 0, {src: '/api/player/stream/1'});
stop.next();
assert.equal(stop.currentTrack, episode);
assert.equal(stop.isPlaying, false);
});
test('prev and seek work on a handed-off episode', () => {
const p = activePlayer([song(1), song(3)], 0, {currentTime: 95, src: '/api/player/stream/1'});
p._executeRemoteCommand({command: 'transfer_state', payload: {
tracks: [song(1), episode], index: 1, track: episode,
position_seconds: 1200, duration_seconds: 1800, paused: false,
}});
// Seeking moves the episode's own position (nothing is loaded in <audio>).
p.seek(1500);
assert.equal(p.currentTime, 1500);
assert.equal(p._devicePlaybackStatePayload().position_seconds, 1500);
// Prev goes to the previous item instead of restarting the episode.
p.prev();
assert.equal(p.currentTrack.id, 1);
assert.deepEqual(p.audio.played, ['/api/player/stream/1']);
// At the start of the queue Prev leaves the episode and its position alone.
const first = activePlayer([episode, song(1)], 0);
first._executeRemoteCommand({command: 'transfer_state', payload: {
tracks: [episode, song(1)], index: 0, track: episode, position_seconds: 1200, paused: true,
}});
first.prev();
assert.equal(first.currentTrack, episode);
assert.equal(first.currentTime, 1200);
});
test('the Jam host keeps its private items against stale participant commands', () => {
const a = song(1);
const b = song(2);
const p = activePlayer([a, episode, b], 0, {src: '/api/player/stream/1'});
// One poll batch: the server checked index 2 against the old order [A, P, B].
for (const command of [
{command: 'queue_move', payload: {from_index: 1, to_index: 2, jam_participant: true}},
{command: 'queue_remove', payload: {index: 2, jam_participant: true}},
]) p._executeRemoteCommand(command);
assert.deepEqual(p.queue.tracks, [a, b, episode]);
p._executeRemoteCommand({command: 'queue_clear', payload: {jam_participant: true}});
assert.equal(p.queue.tracks.length, 3);
p._executeRemoteCommand({command: 'queue_add_end', payload: {tracks: [privateItem], jam_participant: true}});
assert.equal(p.queue.tracks.length, 3);
// A full queue from a stale view brings back nothing the host removed.
p._executeRemoteCommand({command: 'play_from_index', payload: {
tracks: [a, episode, episode, b], index: 0, track: a, jam_participant: true,
}});
assert.deepEqual(p.queue.tracks, [a, b, episode]);
p._executeRemoteCommand({command: 'play_from_index', payload: {
tracks: [a, b], index: 0, track: a, jam_participant: true,
}});
assert.deepEqual(p.queue.tracks, [a, b, episode]);
// Music is still theirs to change, and the host's own commands are not limited.
p._executeRemoteCommand({command: 'queue_remove', payload: {index: 0, jam_participant: true}});
assert.deepEqual(p.queue.tracks, [b, episode]);
p._executeRemoteCommand({command: 'play_from_index', payload: {
tracks: [episode, b], index: 1, track: b, jam_participant: true,
}});
assert.deepEqual(p.queue.tracks, [episode, b]);
p._executeRemoteCommand({command: 'queue_remove', payload: {index: 0}});
assert.deepEqual(p.queue.tracks, [b]);
});
test('leaving a Jam drops the host placeholders from the guest queue', () => {
const placeholder = Object.assign({}, privateItem);
const p = activePlayer([song(1), placeholder, song(2)], 1);
p.currentTrack = placeholder;
p._dropJamPlaceholders();
assert.deepEqual(Array.from(p.queue.tracks, track => track.id), [1, 2]);
// The current placeholder hands over to the next item, paused.
assert.equal(p.queue.currentIndex, 1);
assert.equal(p.currentTrack.id, 2);
assert.equal(p.isPlaying, false);
assert.deepEqual(p.audio.played, []);
const music = activePlayer([song(1), placeholder, song(2)], 2);
music._dropJamPlaceholders();
assert.equal(music.queue.currentIndex, 1);
assert.equal(music.currentTrack.id, 2);
const only = activePlayer([placeholder], 0);
only._dropJamPlaceholders();
assert.deepEqual(only.queue.tracks, []);
assert.equal(only.currentTrack, null);
// The guest's own podcast episodes stay.
const own = activePlayer([episode, song(1)], 0);
own._dropJamPlaceholders();
assert.equal(own.queue.tracks.length, 2);
});
test('the devices store drops placeholders when the guest stops controlling a Jam', () => {
const start = template.indexOf('\n _apply(data) {');
const apply = template.slice(start, template.indexOf('\n },\n', start));
assert.match(apply, /const wasControllingJam = this\.isControllingRemoteJam\(\);/);
assert.match(apply, /if \(wasControllingJam && !this\.isControllingRemoteJam\(\)\) \{\s*Alpine\.store\('player'\)\?\._dropJamPlaceholders\(\);/);
const clear = template.slice(template.indexOf('\n clearJamSelection() {'));
assert.match(clear.slice(0, clear.indexOf('\n },\n')), /if \(wasControllingJam\) Alpine\.store\('player'\)\?\._dropJamPlaceholders\(\);/);
});
-15
View File
@@ -1,15 +0,0 @@
CREATE TABLE furumusic__fed_device_identity (
user_id BIGINT PRIMARY KEY, device_id TEXT NOT NULL, group_id TEXT NOT NULL,
device_name TEXT NOT NULL, local_seq BIGINT DEFAULT 0, last_hlc_ms BIGINT DEFAULT 0,
local_seeded_at_ms BIGINT NOT NULL DEFAULT 1
);
CREATE TABLE furumusic__fed_sync_ops (
user_id BIGINT, op_id TEXT, origin_device_id TEXT, seq BIGINT, kind TEXT,
payload_json JSONB, hlc_ms BIGINT, received_at_ms BIGINT, tombstone BOOLEAN,
PRIMARY KEY(user_id,op_id)
);
CREATE TABLE furumusic__fed_sync_vector (
user_id BIGINT, device_id TEXT, max_seq BIGINT, PRIMARY KEY(user_id,device_id)
);
INSERT INTO furumusic__fed_device_identity(user_id,device_id,group_id,device_name)
VALUES(1,'web_test_one','group_test','one'),(2,'web_test_two','group_test','two');
-121
View File
@@ -1,121 +0,0 @@
const assert = require('node:assert/strict');
const {readFileSync} = require('node:fs');
const {test} = require('node:test');
const vm = require('node:vm');
const source = readFileSync(`${__dirname}/../templates/player/podcast_scripts.html`, 'utf8').replace(/<\/?script>/g, '');
function setup(responder=()=>({})) {
const calls=[],stores={library:{view:'artists',_beginNavigation(){},_afterNavigation(){}},mobile:{closeLibrary(){}},player:{_playLocal(track,options){this.currentTrack=track;this.options=options;},seek(){}}};
vm.runInNewContext(source,{
document:{documentElement:{lang:'ru'},addEventListener(_,fn){fn();}},
Alpine:{store(name,value){if(value)stores[name]=value;return stores[name];}},
fetch:async(url,options)=>{const body=JSON.parse(options.body);calls.push(body);return {ok:true,json:async()=>responder(body)};},
confirm:()=>true,setInterval:()=>1,Date,Map,Set,Blob,location:{hash:''},navigator:{sendBeacon(){}},
});
return {store:stores.podcasts,stores,calls};
}
const episode={id:'ep1:fixture',position_ms:123000,completed:false,metadata:{podcast_id:'pod1:fixture',title:'Episode',duration_ms:3600000,season:2}};
test('podcast playback resumes through the main player with episode identity and its own progress generation',async()=>{
const {store,stores,calls}=setup(()=>({generation:7}));
store.selected={metadata:{title:'Show'}};
await store.play({...episode});
assert.equal(stores.player.currentTrack.id,episode.id);
assert.equal(stores.player.currentTrack.podcast,true);
assert.equal(stores.player.currentTrack.podcast_generation,7);
assert.equal(stores.player.currentTrack.artists[0].name,'Show');
assert.equal(stores.player.options.position_seconds,123);
assert.equal(calls[0].explicit,true);
stores.player.currentTime=130;
store.checkpoint(stores.player);
assert.equal(calls[1].position_ms,130000);
assert.equal(calls[1].generation,7);
});
test('a completed episode starts at zero and restart resets a partial episode',async()=>{
const {store,stores}=setup(()=>({generation:2}));store.selected={metadata:{title:'Show'}};
await store.play({...episode,completed:true});assert.equal(stores.player.options.position_seconds,0);
const item={...episode};await store.restart(item);assert.equal(item.position_ms,0);assert.equal(stores.player.options.position_seconds,0);
});
test('marking unplayed is an explicit reset and advances the active session generation',async()=>{
const {store,stores,calls}=setup(()=>({generation:9}));
const item={...episode,completed:true};stores.player.currentTrack={id:item.id,podcast:true};
await store.mark(item);assert.equal(item.completed,false);assert.equal(item.position_ms,0);
assert.equal(calls[0].explicit,true);assert.equal(calls[0].position_ms,0);assert.equal(stores.player.currentTrack.podcast_generation,9);
});
test('filtering combines season, title and played status without mixing podcasts with music',()=>{
const {store}=setup();store.episodes=[{...episode},{...episode,id:'other',completed:true},{...episode,id:'season3',metadata:{...episode.metadata,season:3}}];
store.filter='epis';store.season='2';store.unplayedOnly=true;assert.deepEqual(Array.from(store.filteredEpisodes(),e=>e.id),[episode.id]);
store.public=[{id:'a',url:'origin'}];store.hits=[{id:'a',url:'origin'},{id:'b',url:'other'}];store.searched=true;assert.equal(store.publicCards().length,2);
});
test('private URL publication requires a separate confirmation; revocation does not republish',async()=>{
const {store,calls}=setup(body=>body.action==='share'&&!body.confirmed?{confirmation_required:true,urls:['https://example.test/feed?token=private']}:body.action==='list'?{mine:[],public:[]}:{ok:true});
await store.share({id:'a',shared:false,metadata:{feed_url:'https://example.test/feed?token=private'}});
// UI actions return task promises through the busy flag; flush the asynchronous load.
while(store.busy)await new Promise(resolve=>setImmediate(resolve));
const shares=calls.filter(c=>c.action==='share');assert.equal(shares.length,2);assert.equal(shares[1].confirmed,true);
});
test('admin and player inline scripts parse without a browser',()=>{
for(const file of ['templates/admin/podcasts.html','templates/player/podcast_scripts.html']) {
const html=readFileSync(`${__dirname}/../${file}`,'utf8');for(const match of html.matchAll(/<script>([\s\S]*?)<\/script>/g))new vm.Script(match[1]);
}
});
test('new episodes do not create gaps in previously loaded pages',async()=>{
let items=Array.from({length:202},(_,i)=>({id:'episode-'+i,metadata:{title:String(i)}}));
const {store}=setup(body=>({episodes:items.slice(body.offset,body.offset+200),has_more:body.offset+200<items.length}));
store.selected={id:'show'};
await store.loadEpisodes();await store.loadEpisodes(true);assert.equal(store.episodes.length,202);
items=[{id:'new',metadata:{title:'new'}},...items];
await store.loadEpisodes();assert.equal(store.episodes.length,203);
assert.equal(store.episodes[0].id,'new');assert.ok(store.episodes.some(e=>e.id==='episode-199'));
});
test('opening podcast navigation starts polling and search results open existing subscriptions',async()=>{
const podcast={id:'show',metadata:{title:'Show'},subscribed:true};
const {store,stores,calls}=setup(body=>body.action==='list'?{mine:[podcast],public:[]}:body.action==='episodes'?{episodes:[],has_more:false}:{});
await store.enter();assert.equal(store.poller,1);assert.equal(stores.library.view,'podcasts');
stores.library.view='search';await store.openResult(podcast);
assert.equal(stores.library.view,'podcast_detail');assert.equal(store.selected.id,'show');
assert.equal(calls.filter(c=>c.action==='add').length,0);
});
test('podcast search displays matching results instead of retaining unrelated public cards',async()=>{
const {store}=setup(()=>({hits:[{id:'matching',metadata:{title:'Found'}}]}));
store.public=[{id:'unrelated'}];store.query='космос';await store.search();
assert.deepEqual(Array.from(store.publicCards(),p=>p.id),['matching']);
store.resetSearch();assert.deepEqual(Array.from(store.publicCards(),p=>p.id),['unrelated']);
});
test('public podcast cards preview details without subscribing; only the subscribe button adds the feed',async()=>{
const pod={id:'public',url:'https://example.test/feed',metadata:{title:'Public',image_url:'https://example.test/cover.jpg'}};
let subscribed=false;
const {store,stores,calls}=setup(body=>{
if(body.action==='add'){subscribed=true;return {id:pod.id};}
if(body.action==='list')return {mine:subscribed?[pod]:[],public:[pod]};
return {episodes:[],has_more:false};
});
await store.open(pod);assert.equal(stores.library.view,'podcast_detail');
assert.equal(store.selected.subscribed,false);assert.equal(calls.filter(c=>c.action==='add').length,0);
assert.equal(calls.filter(c=>c.action==='episodes').length,0);
await store.subscribe();assert.equal(store.selected.subscribed,true);
assert.equal(calls.filter(c=>c.action==='add').length,1);assert.equal(calls.filter(c=>c.action==='episodes').length,1);
assert.equal(store.artwork(pod),pod.metadata.image_url);store.artworkFailed(pod);assert.equal(store.artwork(pod),null);
});
test('back navigation wins over a slow detail request',async()=>{
let finish;
const {store,stores}=setup(body=>body.action==='detail'?new Promise(resolve=>{finish=resolve;}):{mine:[],public:[]});
const opened=store.open('slow');while(!finish)await new Promise(resolve=>setImmediate(resolve));
await store.enter();finish({id:'slow',metadata:{title:'Old'}});await opened;
assert.equal(stores.library.view,'podcasts');assert.equal(store.selected,null);assert.equal(store.loading,false);
});
test('hash routing restores both the podcast list and a selected podcast',()=>{
const script=readFileSync(`${__dirname}/../templates/player/scripts.html`,'utf8');
const start=script.indexOf(' _navigateFromHash(options = {}) {');const end=script.indexOf(' _scrollElement()',start);
const calls=[],location={hash:'#podcasts'};
const context=vm.createContext({GUEST:false,location,URLSearchParams,Alpine:{store(){return {enter(options){calls.push(['list',options]);},open(id,options){calls.push(['detail',id,options]);}};}}});
const library=vm.runInContext('({'+script.slice(start,end)+'})',context);library.goArtists=()=>{throw Error('unexpected artist navigation');};
library._navigateFromHash({fromHash:true});assert.equal(calls[0][0],'list');assert.equal(calls[0][1].fromHash,true);
location.hash='#podcast?id='+encodeURIComponent('pod1:fixture');library._navigateFromHash({fromHash:true});
assert.equal(calls[1][0],'detail');assert.equal(calls[1][1],'pod1:fixture');
});
-14
View File
@@ -1,14 +0,0 @@
CREATE TABLE furumusic__artist(id BIGINT PRIMARY KEY,name TEXT,is_hidden BOOLEAN DEFAULT false,updated_at TEXT DEFAULT '2026-01-01');
CREATE TABLE furumusic__release(id BIGINT PRIMARY KEY,title TEXT,year INTEGER,is_hidden BOOLEAN DEFAULT false,updated_at TEXT DEFAULT '2026-01-01');
CREATE TABLE furumusic__track(id BIGINT PRIMARY KEY,title TEXT,title_sort TEXT,release_id BIGINT,disc_number INTEGER,track_number INTEGER,duration_seconds DOUBLE PRECISION,is_hidden BOOLEAN DEFAULT false,updated_at TEXT DEFAULT '2026-01-01');
CREATE TABLE furumusic__release_artist(release_id BIGINT,artist_id BIGINT);
CREATE TABLE furumusic__track_artist(track_id BIGINT,artist_id BIGINT,role TEXT DEFAULT 'main');
CREATE TABLE furumusic__user_followed_artist(user_id BIGINT,artist_id BIGINT);
CREATE TABLE furumusic__track_ref(local_track_id BIGINT,content_id TEXT);
CREATE TABLE furumusic__listen_event(content_id TEXT,qualified BOOLEAN,user_id BIGINT,listen_id TEXT);
CREATE TABLE furumusic__playlist_track(track_id BIGINT,playlist_id BIGINT);
INSERT INTO furumusic__artist(id,name) VALUES(1,'Алиса');
INSERT INTO furumusic__release(id,title) VALUES(1,'СОЛНЦЕ');
INSERT INTO furumusic__track(id,title,title_sort,release_id,duration_seconds) VALUES(1,'Ελληνικά ТРЕК','ελληνικά трек',1,123);
INSERT INTO furumusic__release_artist VALUES(1,1);
INSERT INTO furumusic__track_artist(track_id,artist_id) VALUES(1,1);