Compare commits
13
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4f17feef71 | ||
|
|
c1cd689ea0 | ||
|
|
a04a7460e6 | ||
|
|
3af0e8ccc9 | ||
|
|
6f3ed4b7ee | ||
|
|
d1be583d1e | ||
|
|
ab7202fc73 | ||
|
|
19139ea830 | ||
|
|
a9736e5914 | ||
|
|
4d0b352258 | ||
|
|
c14ab8dfea | ||
|
|
b558cf381e | ||
|
|
75c67026ac |
No files matched your search
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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:
|
||||
|
||||
|
||||
@@ -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
@@ -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()
|
||||
}
|
||||
|
||||
@@ -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
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
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
@@ -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,
|
||||
|
||||
@@ -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(¤t, record).ok(),
|
||||
None => {
|
||||
let mut record = record.clone();
|
||||
record.normalize();
|
||||
Some(record)
|
||||
}
|
||||
}
|
||||
.map(|mut record| {
|
||||
if let Some(aliases) = &pending {
|
||||
record.add_feed_aliases(aliases);
|
||||
}
|
||||
record
|
||||
});
|
||||
let mut writes: Vec<_> = changed(merged.as_ref().and_then(to_value))
|
||||
.into_iter()
|
||||
.collect();
|
||||
if docs.contains_key(&alias_key) && merged.is_some() {
|
||||
writes.push((alias_key, None));
|
||||
}
|
||||
writes
|
||||
}
|
||||
RelayRecord::Aliases(podcast_id, aliases) => {
|
||||
let sub_key = (SECTION_SUBSCRIPTION, podcast_id.as_str().to_string());
|
||||
if let Some(subscription) = docs.get(&sub_key) {
|
||||
let Some(mut record) = parse::<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, ¤t, aliases)))
|
||||
.into_iter()
|
||||
.collect()
|
||||
}
|
||||
RelayRecord::Share(record) => changed(match current.and_then(parse::<ShareRecord>) {
|
||||
Some(current) => merge_share(¤t, record)
|
||||
.ok()
|
||||
.as_ref()
|
||||
.and_then(to_value),
|
||||
None => to_value(record),
|
||||
})
|
||||
.into_iter()
|
||||
.collect(),
|
||||
RelayRecord::Progress(record) => changed(match current.and_then(parse::<ProgressRecord>) {
|
||||
Some(current) => merge_progress(¤t, record)
|
||||
.ok()
|
||||
.as_ref()
|
||||
.and_then(to_value),
|
||||
None => to_value(record),
|
||||
})
|
||||
.into_iter()
|
||||
.collect(),
|
||||
RelayRecord::Session(session) => changed(match current.and_then(parse::<ListenSession>) {
|
||||
Some(current) => merge_listen_session(¤t, 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, §ion, &value);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn fill_section(snapshot: &mut SyncSnapshot, section: &str, value: &Value) {
|
||||
match section {
|
||||
SECTION_SUBSCRIPTION => snapshot.podcast_subscriptions.extend(parse(value)),
|
||||
SECTION_SHARE => snapshot.podcast_shares.extend(parse(value)),
|
||||
SECTION_PROGRESS => snapshot.podcast_progress.extend(parse(value)),
|
||||
SECTION_SESSION => snapshot.podcast_listen_sessions.extend(parse(value)),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use music_dht::device_sync::{SyncOpPayload, SyncOpWire};
|
||||
use music_dht::podcast::{EpisodeId, PodcastMeta, ProgressStatus};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
fn feed(path: &str) -> FeedUrl {
|
||||
FeedUrl::parse(&format!("https://podcasts.example/{path}")).unwrap()
|
||||
}
|
||||
|
||||
fn meta() -> PodcastMeta {
|
||||
serde_json::from_value(serde_json::json!({
|
||||
"feed_url": feed("feed.xml").as_str(),
|
||||
"title": "Example Cast",
|
||||
"description": "Long channel description",
|
||||
}))
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn podcast() -> PodcastId {
|
||||
PodcastId::from_feed_url(&feed("feed.xml"))
|
||||
}
|
||||
|
||||
fn op(seq: i64, hlc_ms: i64, payload: SyncOpPayload) -> SyncOpWire {
|
||||
SyncOpWire {
|
||||
op_id: format!("tui_a:{seq}"),
|
||||
origin_device_id: "tui_a".into(),
|
||||
seq,
|
||||
hlc_ms,
|
||||
payload,
|
||||
}
|
||||
}
|
||||
|
||||
fn progress(seq: i64, generation: u64, hlc_ms: i64, position_ms: i64) -> SyncOpWire {
|
||||
let podcast_id = podcast();
|
||||
op(
|
||||
seq,
|
||||
hlc_ms,
|
||||
SyncOpPayload::PodcastProgressSet {
|
||||
episode_id: EpisodeId::from_guid(&podcast_id, "ep-1").unwrap(),
|
||||
podcast_id,
|
||||
position_ms,
|
||||
status: ProgressStatus::InProgress,
|
||||
generation,
|
||||
session_id: format!("s{generation}"),
|
||||
episode: None,
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
/// Applies records to an in-memory table with the production plan.
|
||||
fn apply(state: &mut BTreeMap<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
@@ -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
@@ -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?;
|
||||
}
|
||||
|
||||
@@ -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
@@ -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
@@ -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
@@ -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, ¤t_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,
|
||||
|
||||
@@ -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()
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -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()));
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
@@ -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(¤t, &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 ¤t {
|
||||
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(¤t, &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(¤t, &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, ¤t, 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;
|
||||
}
|
||||
});
|
||||
}
|
||||
@@ -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);
|
||||
@@ -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();
|
||||
}
|
||||
@@ -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",
|
||||
),
|
||||
])
|
||||
}
|
||||
}
|
||||
@@ -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>
|
||||
@@ -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">
|
||||
|
||||
@@ -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 %}
|
||||
@@ -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>
|
||||
@@ -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>
|
||||
@@ -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>
|
||||
@@ -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>
|
||||
@@ -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>
|
||||
@@ -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>
|
||||
@@ -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
@@ -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
@@ -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 }"
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;});
|
||||
@@ -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\(\);/);
|
||||
});
|
||||
@@ -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');
|
||||
@@ -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');
|
||||
});
|
||||
@@ -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);
|
||||
Reference in new issue
Block a user