Compare commits

...
4 Commits
Author SHA1 Message Date
ab eefe8a9777 Fix podcast page 2026-11-22 17:49:23 +02:00
ab 319f0bcba7 Fixed podcast sync 2026-11-22 17:11:37 +02:00
ab 441316f78f Fix lock 2026-11-22 16:12:52 +02:00
ab be7ccd5b4f Added podcasts support 2026-11-22 16:05:37 +02:00
35 changed files with 3750 additions and 294 deletions

No files matched your search

Generated
+58 -39
View File
@@ -453,6 +453,12 @@ 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"
@@ -805,9 +811,9 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
[[package]]
name = "combine"
version = "4.6.8"
version = "4.6.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cfc320937d09e6de266b31b9afb480f197d7a861be86be7cb2ea7e5d1bfffc5e"
checksum = "4356eba6976435498d05a311ee9fc486da3bc81c200d3f0d7dd9703b41913f92"
dependencies = [
"bytes",
"memchr",
@@ -1988,7 +1994,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
[[package]]
name = "furumusic"
version = "0.12.4"
version = "0.12.5"
dependencies = [
"anyhow",
"async-stream",
@@ -2161,9 +2167,9 @@ dependencies = [
[[package]]
name = "generator"
version = "0.8.9"
version = "0.8.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b3b854b0e584ead1a33f18b2fcad7cf7be18b3875c78816b753639aa501513ae"
checksum = "1be81b31c9ce4caf7f3178eeb90662bb1864d3ad363ec6bdada3201adff19c37"
dependencies = [
"cc",
"cfg-if",
@@ -3351,9 +3357,9 @@ dependencies = [
[[package]]
name = "js-sys"
version = "0.3.104"
version = "0.3.106"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e0c1080212aad755ea003d18543e8768dd432c48819efd73a7bf1e39b7a5a3a"
checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"
dependencies = [
"cfg-if",
"futures-util",
@@ -3403,9 +3409,9 @@ checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
[[package]]
name = "libredox"
version = "0.1.23"
version = "0.1.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d8f1ea3f21fd3405dcaf6c9b5c1630af9afc422d9073ea39c5f6d6c772e08ed"
checksum = "61ff90caf6077a803a240f62fdbe88645a890bbca49ef8174c3cb0404362171d"
dependencies = [
"bitflags 2.13.1",
"libc",
@@ -3900,16 +3906,18 @@ dependencies = [
[[package]]
name = "music-dht"
version = "0.5.0"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4c3f75d49d3a742a6777a1c4cc53f397399dfc9ddb70034c57aeb44d75d2ee4f"
checksum = "7ce81f361952228654c28a46e41555f2c3d1520bf8c6c76562e7a53f70dd38e1"
dependencies = [
"async-trait",
"blake3",
"data-encoding",
"encoding_rs",
"federation-net",
"futures",
"postcard",
"quick-xml 0.41.0",
"rand 0.9.5",
"rusqlite",
"serde",
@@ -3918,6 +3926,7 @@ dependencies = [
"tokio",
"tracing",
"unicode-normalization",
"url",
]
[[package]]
@@ -4040,9 +4049,9 @@ dependencies = [
[[package]]
name = "netdev"
version = "0.46.2"
version = "0.46.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4db4135b187ddae3b6813c4f9d9ac9d5181859fa6a08b4e006c63a130974ed62"
checksum = "c3c52c2584961c68f5a6e3356797344061f818c93b8acc9cd6d7e284795e563e"
dependencies = [
"block2",
"dispatch2",
@@ -4158,7 +4167,7 @@ dependencies = [
"n0-future",
"n0-watcher",
"netdev 0.45.0",
"netdev 0.46.2",
"netdev 0.46.3",
"netlink-packet-core 0.8.2",
"netlink-packet-route 0.31.0",
"netlink-proto",
@@ -4456,9 +4465,9 @@ dependencies = [
[[package]]
name = "objc2"
version = "0.6.4"
version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
checksum = "08849bbd4767dfae9457696856ae1c84fe4e0281bbe4a7abff2d0e06fb7981f8"
dependencies = [
"objc2-encode",
]
@@ -4633,9 +4642,9 @@ dependencies = [
[[package]]
name = "openssl-probe"
version = "0.2.1"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
checksum = "7e036b411754132fd6b74e94b74e9a13c5cf606fa93d1885c35860d3060820b1"
[[package]]
name = "openssl-sys"
@@ -4927,13 +4936,13 @@ checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
[[package]]
name = "plist"
version = "1.10.0"
version = "1.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7da1d65da6dd5d1e44199ac0f58712d241c0f439f80adea8924d832384087f85"
checksum = "327a4cb2ad49dc48adfdc9da89e22c64d488b508c67a044d71ba729e4521a285"
dependencies = [
"base64 0.22.1",
"base64 0.23.1",
"indexmap 2.14.1",
"quick-xml 0.41.0",
"quick-xml 0.42.0",
"serde",
"time",
]
@@ -5175,6 +5184,15 @@ 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"
@@ -5669,9 +5687,9 @@ dependencies = [
[[package]]
name = "rustix"
version = "1.1.4"
version = "1.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
checksum = "891efababe418670775f199f0d233d84843c227a0949a883ce15b37c78d6629d"
dependencies = [
"bitflags 2.13.1",
"errno",
@@ -7763,9 +7781,9 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
[[package]]
name = "wasm-bindgen"
version = "0.2.127"
version = "0.2.129"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b70935747edd64d89de3efa29d73789b806c15798f8e7dca4d8ac356b50ce70"
checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"
dependencies = [
"cfg-if",
"once_cell",
@@ -7776,19 +7794,20 @@ dependencies = [
[[package]]
name = "wasm-bindgen-futures"
version = "0.4.77"
version = "0.4.79"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6b7777d5cc23d0e91404e53ce2d5e8ec7acae3026b16233dba62cd3246457950"
checksum = "3cbab34de2d982e9b48e18d216d04c4a6f641066ff19ffb699980f591ee3610e"
dependencies = [
"js-sys",
"tokio",
"wasm-bindgen",
]
[[package]]
name = "wasm-bindgen-macro"
version = "0.2.127"
version = "0.2.129"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77775f8f3f7217702089053b94958f8f54061a3f663417df76e19cbdcca29bc1"
checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"
dependencies = [
"quote",
"wasm-bindgen-macro-support",
@@ -7796,22 +7815,22 @@ dependencies = [
[[package]]
name = "wasm-bindgen-macro-support"
version = "0.2.127"
version = "0.2.129"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e11d33f857dc2fb11b8bc75aee111aa9cbeb12cd9f25efd3d4c2a3dd4e235284"
checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"
dependencies = [
"bumpalo",
"proc-macro2",
"quote",
"syn 2.0.119",
"syn 3.0.4",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
version = "0.2.127"
version = "0.2.129"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ef64dbcc55df09c7e5a46182d181c2cfa3e925f3da937ea764728b4bbb9dcbf"
checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"
dependencies = [
"unicode-ident",
]
@@ -7844,9 +7863,9 @@ dependencies = [
[[package]]
name = "web-sys"
version = "0.3.104"
version = "0.3.106"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c435338968042f4f59a557f690a253676d47ce13ceb55d70100e7facf6620a30"
checksum = "88261b9deccee56594c11a3460c462c41f58d148598fe70ad77070126a68aba4"
dependencies = [
"js-sys",
"wasm-bindgen",
@@ -7864,9 +7883,9 @@ dependencies = [
[[package]]
name = "webpki-root-certs"
version = "1.0.9"
version = "1.0.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b"
checksum = "e49d0e65abc00c142e8f9428da991da9f1a250c39be97459901eb12b9b49f62a"
dependencies = [
"rustls-pki-types",
]
+2 -2
View File
@@ -1,6 +1,6 @@
[package]
name = "furumusic"
version = "0.12.4"
version = "0.12.5"
edition = "2024"
description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
@@ -56,4 +56,4 @@ uuid = "1"
librqbit = { version = "8.1.1", features = ["disable-upload"] }
# P2P federation: publishes the library into a shared DHT and serves audio /
# catalogs to furumi peers (TUI clients) over the frid stack.
music-dht = "0.5.0"
music-dht = { version = "0.6.0", features = ["podcast-feed"] }
+44
View File
@@ -2,6 +2,50 @@
[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
+26
View File
@@ -55,6 +55,32 @@ 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:
+105 -15
View File
@@ -3978,11 +3978,11 @@ async fn search_tracks(
LEFT JOIN furumusic__release r ON r.id = t.release_id \
LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id AND ta.role = 'main' \
LEFT JOIN furumusic__artist a ON a.id = ta.artist_id \
WHERE t.title ILIKE $1 OR COALESCE(r.title::text, '') ILIKE $1 OR COALESCE(a.name::text, '') ILIKE $1 \
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 \
GROUP BY t.id, r.id, r.title \
ORDER BY CASE \
WHEN LOWER(t.title::text) = LOWER($2) THEN 0 \
WHEN t.title ILIKE $3 THEN 1 \
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 \
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 ILIKE ");
qb.push(" AND (r.title COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR a.name ILIKE ");
qb.push(" OR a.name COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern);
qb.push(")");
}
@@ -4322,16 +4322,16 @@ fn push_library_search_filter(
qb.push(")");
}
"tracks" => {
qb.push(" AND (t.title ILIKE ");
qb.push(" AND (t.title COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR r.title ILIKE ");
qb.push(" OR r.title COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR a.name ILIKE ");
qb.push(" OR a.name COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern);
qb.push(")");
}
_ => {
qb.push(" AND a.name ILIKE ");
qb.push(" AND a.name COLLATE furumusic_unicode 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 ILIKE ");
qb.push(" AND a.name COLLATE furumusic_unicode 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 ILIKE ");
qb.push(" AND (r.title COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR a.name ILIKE ");
qb.push(" OR a.name COLLATE furumusic_unicode 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 ILIKE ");
qb.push(" AND (t.title COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR r.title ILIKE ");
qb.push(" OR r.title COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern.clone());
qb.push(" OR a.name ILIKE ");
qb.push(" OR a.name COLLATE furumusic_unicode ILIKE ");
qb.push_bind(pattern);
qb.push(")");
}
@@ -4612,6 +4612,96 @@ 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()
}
+4 -2
View File
@@ -5,8 +5,8 @@ use std::time::Duration;
use anyhow::Result;
use music_dht::StreamAcceptor;
use music_dht::capabilities::{
CAPABILITIES_PROTOCOL_VERSION, CapabilityManifest, CapabilityMessage, JAM_ID, SIMILARITY_ID,
read_message, write_message,
CAPABILITIES_PROTOCOL_VERSION, CapabilityManifest, CapabilityMessage, DEVICE_SYNC_ID, JAM_ID,
SIMILARITY_ID, read_message, write_message,
};
use super::serve::AUDIO_PROTOCOL_VERSION;
@@ -15,6 +15,8 @@ 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,
+167 -230
View File
@@ -5,9 +5,7 @@
//! protocol as the TUI clients on `furumi/sync/1` and maps operations into
//! user-scoped Postgres state.
use music_dht::playback::{
Announcement, Checkpoint, CommandStamp, Config as PlaybackConfig, Engine,
};
use music_dht::playback::{Announcement, Checkpoint, Config as PlaybackConfig, Engine};
use std::collections::BTreeMap;
use std::str::FromStr;
use std::sync::Arc;
@@ -27,7 +25,7 @@ use super::{TransportStats, record_stream_transport};
pub const SYNC_ALPN: &[u8] = b"furumi/sync/2";
const CLIENT_VERSION: &str = env!("CARGO_PKG_VERSION");
const PROTOCOL_VERSION: u16 = 3;
pub(super) const PROTOCOL_VERSION: u16 = 4;
const INVITE_TTL_MS: i64 = 10 * 60 * 1000;
const PAIRING_WAIT_MS: i64 = 5 * 60 * 1000;
const PAIRING_RETRY_DELAY: Duration = Duration::from_secs(1);
@@ -125,220 +123,12 @@ struct DeviceProfileWire {
updated_at_ms: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct SyncedFedTrack {
item_id: String,
owner: String,
title: String,
#[serde(default)]
artist_names: Vec<String>,
#[serde(default)]
featured_artist_names: Vec<String>,
year: Option<i32>,
duration_seconds: Option<i64>,
content_id: String,
release_title: Option<String>,
track_number: Option<i32>,
disc_number: Option<i32>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct PlaybackTrack {
id: i64,
title: String,
track_number: Option<i32>,
disc_number: Option<i32>,
duration_seconds: f64,
#[serde(default)]
artist_names: Vec<String>,
#[serde(default)]
featured_artist_names: Vec<String>,
release_id: i64,
release_title: String,
release_year: Option<i32>,
#[serde(default)]
file_path: String,
content_id: Option<String>,
audio_format: Option<String>,
audio_bitrate: Option<i32>,
audio_sample_rate: Option<i32>,
audio_bit_depth: Option<i32>,
file_size_bytes: Option<i64>,
#[serde(default)]
play_count: i64,
#[serde(default)]
fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
enum PlaybackRepeat {
#[default]
Off,
One,
All,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct PlaybackStateWire {
#[serde(default)]
queue: Vec<PlaybackTrack>,
#[serde(default)]
queue_pos: usize,
playing: bool,
paused: bool,
#[serde(default)]
idle_since_ms: Option<i64>,
position_secs: f64,
#[serde(default)]
volume: u8,
shuffle: bool,
repeat: PlaybackRepeat,
}
type PlaybackSnapshot = music_dht::playback::Snapshot<PlaybackStateWire>;
type PlaybackCommand = music_dht::playback::Command<PlaybackStateWire>;
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SyncOpWire {
op_id: String,
origin_device_id: String,
seq: i64,
hlc_ms: i64,
payload: SyncOpPayload,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
enum SyncOpPayload {
TrackLikeSet {
content_id: String,
liked: bool,
#[serde(default)]
fed: Option<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,
},
}
impl SyncOpPayload {
fn is_tombstone(&self) -> bool {
matches!(
self,
SyncOpPayload::TrackLikeSet { liked: false, .. }
| SyncOpPayload::PlaylistDeleted { .. }
| SyncOpPayload::PlaylistTrackRemoved { .. }
| SyncOpPayload::DeviceRevoked { .. }
)
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct SyncSnapshot {
#[serde(default)]
likes: Vec<SnapshotLike>,
#[serde(default)]
unlikes: Vec<SnapshotLikeTombstone>,
#[serde(default)]
playlists: Vec<SnapshotPlaylist>,
#[serde(default)]
deleted_playlists: Vec<SnapshotPlaylistTombstone>,
#[serde(default)]
removed_playlist_items: Vec<SnapshotPlaylistItemTombstone>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SnapshotLike {
content_id: String,
hlc_ms: i64,
op_id: String,
#[serde(default)]
fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SnapshotLikeTombstone {
content_id: String,
hlc_ms: i64,
op_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SnapshotPlaylist {
playlist_id: String,
title: String,
hlc_ms: i64,
op_id: String,
#[serde(default)]
items: Vec<SnapshotPlaylistItem>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SnapshotPlaylistTombstone {
playlist_id: String,
hlc_ms: i64,
op_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SnapshotPlaylistItem {
content_id: String,
position: i64,
hlc_ms: i64,
op_id: String,
#[serde(default)]
fed: Option<SyncedFedTrack>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SnapshotPlaylistItemTombstone {
playlist_id: String,
content_id: String,
hlc_ms: i64,
op_id: String,
}
use music_dht::device_sync::{
PlaybackCommand, PlaybackRepeat, PlaybackSnapshot, PlaybackStateWire, PlaybackTrack,
SnapshotLike, SnapshotLikeTombstone, SnapshotPlaylist, SnapshotPlaylistItem,
SnapshotPlaylistItemTombstone, SnapshotPlaylistTombstone, SyncOpPayload, SyncOpWire,
SyncSnapshot, SyncedFedTrack,
};
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
@@ -1180,8 +970,9 @@ async fn try_connect_invite(
let devices = device_profiles(pool, user_id).await?;
let vector = vector(pool, user_id).await?;
let ops = ops_for_peer(pool, user_id, &invite.device_id).await?;
let snapshot = snapshot(pool, user_id).await?;
let snapshot = snapshot_for_peer(pool, user_id, &invite.device_id).await?;
let playback = local_playback_snapshot(pool, Arc::clone(&hub), user_id, &identity).await;
let playback = playback_for_peer(pool, user_id, &invite.device_id, playback).await?;
let mut stream = service.open_stream(peer, SYNC_ALPN).await?;
record_stream_transport(&transport_stats, "device-sync", "outbound", "open", &stream);
write_msg(
@@ -1235,6 +1026,7 @@ async fn try_connect_invite(
apply_device_profiles(pool, user_id, &devices).await?;
apply_snapshot(pool, user_id, snapshot).await?;
apply_ops(pool, Arc::clone(&hub), user_id, ops).await?;
crate::podcasts::sync::exchange_complete(pool, user_id, &invite.device_id).await?;
record_local_op(
pool,
user_id,
@@ -1459,6 +1251,7 @@ async fn handle_pair_request(
}
apply_snapshot(pool, user_id, incoming_snapshot).await?;
apply_ops(pool, Arc::clone(&hub), user_id, ops).await?;
crate::podcasts::sync::exchange_complete(pool, user_id, &profile.device_id).await?;
apply_device_profiles(pool, user_id, &requester_group_devices).await?;
note_peer_vector(pool, user_id, &profile.device_id, &incoming_vector).await?;
sqlx::query("UPDATE furumusic__fed_device_invite SET used_at_ms = $2 WHERE invite_id = $1")
@@ -1476,8 +1269,9 @@ async fn handle_pair_request(
let devices = device_profiles(pool, user_id).await?;
let vector = vector(pool, user_id).await?;
let ops = ops_for_peer(pool, user_id, &profile.device_id).await?;
let snapshot = snapshot(pool, user_id).await?;
let snapshot = snapshot_for_peer(pool, user_id, &profile.device_id).await?;
let playback = local_playback_snapshot(pool, hub, user_id, &identity).await;
let playback = playback_for_peer(pool, user_id, &profile.device_id, playback).await?;
write_msg(
&mut stream,
&WireMessage::PairResponse {
@@ -1522,8 +1316,9 @@ async fn handle_hello(
return write_sync_reject(stream, "sync group mismatch").await;
}
profile.endpoint_id = stream.peer_id.to_string();
apply_device_profile(pool, user_id, &profile, false).await?;
apply_device_profiles(pool, user_id, &devices).await?;
// A sender's own current report takes precedence over relayed profiles.
apply_device_profile(pool, user_id, &profile, false).await?;
if let Some(playback) = playback {
apply_playback_snapshot(
Arc::clone(&hub),
@@ -1536,6 +1331,7 @@ async fn handle_hello(
}
apply_snapshot(pool, user_id, incoming_snapshot).await?;
apply_ops(pool, Arc::clone(&hub), user_id, ops).await?;
crate::podcasts::sync::exchange_complete(pool, user_id, &profile.device_id).await?;
note_peer_vector(pool, user_id, &profile.device_id, &incoming_vector).await?;
mark_seen(
pool,
@@ -1557,8 +1353,9 @@ async fn handle_hello(
devices.push(own_profile);
let vector = vector(pool, user_id).await?;
let ops = ops_for_peer(pool, user_id, &profile.device_id).await?;
let snapshot = snapshot(pool, user_id).await?;
let snapshot = snapshot_for_peer(pool, user_id, &profile.device_id).await?;
let playback = local_playback_snapshot(pool, hub, user_id, &identity).await;
let playback = playback_for_peer(pool, user_id, &profile.device_id, playback).await?;
write_msg(
&mut stream,
&WireMessage::SyncResponse {
@@ -1592,8 +1389,9 @@ async fn sync_device(
let devices = device_profiles(pool, user_id).await?;
let vector = vector(pool, user_id).await?;
let ops = ops_for_peer(pool, user_id, &device.device_id).await?;
let snapshot = snapshot(pool, user_id).await?;
let snapshot = snapshot_for_peer(pool, user_id, &device.device_id).await?;
let playback = local_playback_snapshot(pool, Arc::clone(&hub), user_id, &identity).await;
let playback = playback_for_peer(pool, user_id, &device.device_id, playback).await?;
let mut stream = service.open_stream(peer, SYNC_ALPN).await?;
record_stream_transport(&transport_stats, "device-sync", "outbound", "open", &stream);
write_msg(
@@ -1637,6 +1435,7 @@ async fn sync_device(
}
apply_snapshot(pool, user_id, snapshot).await?;
apply_ops(pool, hub, user_id, ops).await?;
crate::podcasts::sync::exchange_complete(pool, user_id, &device.device_id).await?;
note_peer_vector(pool, user_id, &device.device_id, &vector).await?;
mark_seen(
pool,
@@ -2049,6 +1848,34 @@ async fn record_local_op(
Ok(())
}
pub(crate) async fn record_podcast_op(
pool: &sqlx::PgPool,
user_id: i64,
payload: SyncOpPayload,
) -> Result<()> {
let identity = ensure_identity(pool, user_id, "").await?;
let mut tx = pool.begin().await?;
sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1,7512))")
.bind(format!("podcast-sync:{user_id}"))
.execute(&mut *tx)
.await?;
let row=sqlx::query("UPDATE furumusic__fed_device_identity SET local_seq=local_seq+1,last_hlc_ms=GREATEST($2,last_hlc_ms+1) WHERE user_id=$1 RETURNING local_seq,last_hlc_ms").bind(user_id).bind(now_ms()).fetch_one(&mut *tx).await?;
let seq: i64 = row.get("local_seq");
let op = SyncOpWire {
op_id: format!("{}:{seq}", identity.device_id),
origin_device_id: identity.device_id,
seq,
hlc_ms: row.get("last_hlc_ms"),
payload,
};
op.validate_podcast()?;
sqlx::query("INSERT INTO furumusic__fed_sync_ops(user_id,op_id,origin_device_id,seq,kind,payload_json,hlc_ms,received_at_ms,tombstone) VALUES($1,$2,$3,$4,$5,$6,$7,$8,false)").bind(user_id).bind(&op.op_id).bind(&op.origin_device_id).bind(seq).bind(payload_kind(&op.payload)).bind(serde_json::to_value(&op.payload)?).bind(op.hlc_ms).bind(now_ms()).execute(&mut *tx).await?;
sqlx::query("INSERT INTO furumusic__fed_sync_vector(user_id,device_id,max_seq) VALUES($1,$2,$3) ON CONFLICT(user_id,device_id) DO UPDATE SET max_seq=GREATEST(furumusic__fed_sync_vector.max_seq,EXCLUDED.max_seq)").bind(user_id).bind(&op.origin_device_id).bind(seq).execute(&mut *tx).await?;
crate::podcasts::sync::apply_op_tx(&mut tx, user_id, &op).await?;
tx.commit().await?;
Ok(())
}
async fn apply_ops(
pool: &sqlx::PgPool,
hub: Arc<PlayerDeviceHub>,
@@ -2078,7 +1905,7 @@ async fn apply_ops(
.execute(pool)
.await?
.rows_affected();
if inserted > 0 {
if inserted > 0 || op.payload.is_podcast() {
let _ = apply_op(pool, Arc::clone(&hub), user_id, &op).await?;
}
sqlx::query(
@@ -2127,6 +1954,9 @@ async fn apply_op(
user_id: i64,
op: &SyncOpWire,
) -> Result<bool> {
if op.payload.is_podcast() {
return crate::podcasts::sync::apply_op(pool, user_id, op).await;
}
match &op.payload {
SyncOpPayload::TrackLikeSet {
content_id,
@@ -2201,12 +2031,16 @@ async fn apply_op(
client_version,
endpoint_ticket,
endpoint_id,
protocol_version,
} => {
let profile = DeviceProfileWire {
device_id: op.origin_device_id.clone(),
name: name.clone(),
client_version: client_version.clone(),
protocol_version: PROTOCOL_VERSION,
protocol_version: music_dht::device_sync::profile_protocol_version(
*protocol_version,
Some(peer_protocol_version(pool, user_id, &op.origin_device_id).await?),
),
endpoint_id: endpoint_id.clone(),
endpoint_ticket: endpoint_ticket.clone(),
revoked: false,
@@ -2240,6 +2074,7 @@ async fn apply_op(
SyncOpPayload::ListenRecorded { event } => {
apply_listen_event(pool, user_id, &op.origin_device_id, event).await
}
_ => Ok(false),
}
}
@@ -2605,6 +2440,8 @@ async fn apply_playlist_item_state(
}
async fn apply_snapshot(pool: &sqlx::PgPool, user_id: i64, snapshot: SyncSnapshot) -> Result<()> {
crate::podcasts::sync::apply_snapshot(pool, user_id, &snapshot).await?;
crate::podcasts::sync::refresh_received(pool.clone());
for like in snapshot.likes {
apply_like_state(
pool,
@@ -2690,7 +2527,12 @@ async fn apply_device_profiles(
devices: &[DeviceProfileWire],
) -> Result<()> {
for profile in devices {
apply_device_profile(pool, user_id, profile, false).await?;
let mut relayed = profile.clone();
relayed.protocol_version = music_dht::device_sync::relayed_protocol_version(
profile.protocol_version,
Some(peer_protocol_version(pool, user_id, &profile.device_id).await?),
);
apply_device_profile(pool, user_id, &relayed, false).await?;
}
Ok(())
}
@@ -2846,6 +2688,14 @@ async fn apply_playback_command(
};
let authority = authority.as_ref();
let origin = &op.origin_device_id;
if peer_protocol_version(pool, user_id, origin).await? < 4
&& let Some(state) = hub.playback_state_json_for_commands(user_id)
{
let local = playback_state_from_browser_json(pool, state).await?;
if !music_dht::device_sync::playback_command_allowed_from_peer(&local, 3) {
return Ok(());
}
}
let op_id = &op.op_id;
let identity = ensure_identity(pool, user_id, "").await?;
let Some(authority) = authority else {
@@ -3009,6 +2859,7 @@ pub async fn record_web_playback_command(
ensure_web_playback_target(pool, user_id, target_device_id).await?;
let next_state = browser_state_for_command(command, payload, current_state)?;
let wire = playback_state_from_browser_json(pool, next_state.clone()).await?;
require_playback_peer(pool, user_id, target_device_id, &wire).await?;
record_local_op(
pool,
user_id,
@@ -3037,6 +2888,7 @@ pub async fn record_web_active_transfer(
) -> Result<()> {
ensure_web_playback_target(pool, user_id, target_device_id).await?;
let wire = playback_state_from_browser_json(pool, state).await?;
require_playback_peer(pool, user_id, target_device_id, &wire).await?;
let target_name = web_playback_target_name(pool, user_id, target_device_id).await?;
let identity = ensure_identity(pool, user_id, "").await?;
with_playback_engine(pool, user_id, &identity, |engine| {
@@ -3710,6 +3562,7 @@ async fn playback_state_from_browser_json(
}
}
Ok(PlaybackStateWire {
playback_rate: Some(1.0),
queue,
queue_pos: state
.get("index")
@@ -3754,6 +3607,20 @@ async fn playback_track_from_track_json(
track_id: i64,
track: &serde_json::Value,
) -> Result<PlaybackTrack> {
if let Some(source) = track.get("podcast_source") {
let source: music_dht::device_sync::PlaybackSource =
serde_json::from_value(source.clone())?;
match source {
music_dht::device_sync::PlaybackSource::PodcastEpisode(episode) => {
episode.validate()?;
return Ok(PlaybackTrack::podcast_episode(*episode));
}
music_dht::device_sync::PlaybackSource::Private => {
return Ok(PlaybackTrack::private_placeholder());
}
music_dht::device_sync::PlaybackSource::Music => {}
}
}
Ok(PlaybackTrack {
id: track_id,
title: track
@@ -3819,6 +3686,7 @@ async fn playback_track_from_track_json(
.and_then(serde_json::Value::as_i64),
play_count: 0,
fed: None,
source: None,
})
}
@@ -3842,6 +3710,12 @@ async fn resolve_playback_tracks(
) -> Result<Vec<serde_json::Value>> {
let mut out = Vec::new();
for (index, track) in tracks.iter().enumerate() {
if track.requires_podcast_support() {
let mut value = placeholder_playback_track(track, index, None);
value["podcast_source"] = serde_json::to_value(&track.source)?;
out.push(value);
continue;
}
let content_id = track
.content_id
.as_deref()
@@ -4476,6 +4350,7 @@ async fn ops_for_peer(
user_id: i64,
peer_device_id: &str,
) -> Result<Vec<SyncOpWire>> {
let peer_version = peer_protocol_version(pool, user_id, peer_device_id).await?;
let rows = sqlx::query(
"SELECT o.op_id, o.origin_device_id, o.seq, o.hlc_ms, o.payload_json
FROM furumusic__fed_sync_ops o
@@ -4485,6 +4360,7 @@ async fn ops_for_peer(
AND a.origin_device_id = o.origin_device_id
WHERE o.user_id = $1
AND o.seq > COALESCE(a.max_seq, 0)
AND ($5 >= 4 OR o.kind NOT LIKE 'podcast_%')
AND (
o.kind != 'playback_command'
OR (
@@ -4499,9 +4375,11 @@ async fn ops_for_peer(
.bind(peer_device_id)
.bind(now_ms().saturating_sub(PLAYBACK_COMMAND_TTL_MS))
.bind(MAX_OPS_PER_BATCH)
.bind(peer_version as i32)
.fetch_all(pool)
.await?;
rows.into_iter()
let ops: Vec<SyncOpWire> = rows
.into_iter()
.map(|row| {
let payload_json: serde_json::Value = row.get("payload_json");
Ok(SyncOpWire {
@@ -4512,7 +4390,58 @@ async fn ops_for_peer(
payload: serde_json::from_value(payload_json)?,
})
})
.collect()
.collect::<Result<Vec<_>>>()?;
Ok(ops
.into_iter()
.filter(|op| music_dht::device_sync::op_allowed_for_peer(&op.payload, peer_version))
.collect())
}
async fn peer_protocol_version(pool: &sqlx::PgPool, user_id: i64, device_id: &str) -> Result<u16> {
let version: Option<i32> = sqlx::query_scalar(
"SELECT protocol_version FROM furumusic__fed_device WHERE user_id=$1 AND device_id=$2",
)
.bind(user_id)
.bind(device_id)
.fetch_optional(pool)
.await?;
Ok(version.unwrap_or(3) as u16)
}
async fn snapshot_for_peer(
pool: &sqlx::PgPool,
user_id: i64,
device_id: &str,
) -> Result<SyncSnapshot> {
Ok(snapshot(pool, user_id)
.await?
.for_peer(peer_protocol_version(pool, user_id, device_id).await?))
}
async fn playback_for_peer(
pool: &sqlx::PgPool,
user_id: i64,
device_id: &str,
playback: Option<PlaybackSnapshot>,
) -> Result<Option<PlaybackSnapshot>> {
let version = peer_protocol_version(pool, user_id, device_id).await?;
Ok(playback.filter(|snapshot| {
music_dht::device_sync::playback_allowed_for_peer(&snapshot.state, version)
}))
}
async fn require_playback_peer(
pool: &sqlx::PgPool,
user_id: i64,
device_id: &str,
state: &PlaybackStateWire,
) -> Result<()> {
if !music_dht::device_sync::playback_allowed_for_peer(
state,
peer_protocol_version(pool, user_id, device_id).await?,
) {
anyhow::bail!("update the connected player to play podcast queues");
}
Ok(())
}
async fn snapshot(pool: &sqlx::PgPool, user_id: i64) -> Result<SyncSnapshot> {
@@ -4601,13 +4530,16 @@ async fn snapshot(pool: &sqlx::PgPool, user_id: i64) -> Result<SyncSnapshot> {
op_id: row.get("op_id"),
})
.collect();
Ok(SyncSnapshot {
let mut result = SyncSnapshot {
likes,
unlikes,
playlists,
deleted_playlists,
removed_playlist_items,
})
..SyncSnapshot::default()
};
crate::podcasts::sync::append_snapshot(pool, user_id, &mut result).await?;
Ok(result)
}
async fn snapshot_playlist_items(
@@ -4852,6 +4784,11 @@ fn payload_kind(payload: &SyncOpPayload) -> &'static str {
SyncOpPayload::DeviceRevoked { .. } => "device_revoked",
SyncOpPayload::PlaybackCommand { .. } => "playback_command",
SyncOpPayload::ListenRecorded { .. } => "listen_recorded",
SyncOpPayload::PodcastSubscriptionSet { .. } => "podcast_subscription_set",
SyncOpPayload::PodcastShareSet { .. } => "podcast_share_set",
SyncOpPayload::PodcastFeedAliasesAdded { .. } => "podcast_feed_aliases_added",
SyncOpPayload::PodcastProgressSet { .. } => "podcast_progress_set",
SyncOpPayload::PodcastListenRecorded { .. } => "podcast_listen_recorded",
}
}
+54
View File
@@ -30,6 +30,7 @@ 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::{
@@ -60,6 +61,7 @@ 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<()>>,
}
@@ -498,6 +500,7 @@ 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) =
@@ -511,6 +514,30 @@ 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"),
@@ -602,8 +629,12 @@ 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,
@@ -671,6 +702,29 @@ 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()
+1 -1
View File
@@ -305,7 +305,7 @@ translations! {
player_likes_count: "likes" , "лайков";
player_likes_playlist: "Likes" , "Лайки";
player_listened: "listened" , "прослушано";
player_search_placeholder: "Search artists, releases, tracks..." , "Поиск артистов, релизов, треков...";
player_search_placeholder: "Search artists, releases, tracks, podcasts..." , "Поиск артистов, релизов, треков, подкастов...";
player_search_similar_to: "Search similar to:" , "Поиск похожих на:";
player_find_similar: "Find similar tracks" , "Найти похожие треки";
player_similarity_failed: "Similarity search failed" , "Не удалось найти похожие треки";
+6
View File
@@ -15,6 +15,7 @@ mod metrics;
mod music;
mod oidc;
mod player;
mod podcasts;
mod scheduler;
mod similarity;
mod torrents;
@@ -63,6 +64,7 @@ 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)
}
@@ -579,6 +581,10 @@ 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),
+51
View File
@@ -2838,6 +2838,55 @@ pub mod db_migrations {
&[Operation::custom(add_import_playlist_destinations).build()];
}
#[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?;
}
}
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?;
}
}
Ok(())
}
#[derive(Debug, Copy, Clone)]
pub struct M0055PodcastSyncAndUnicodeSearch;
impl migrations::Migration for M0055PodcastSyncAndUnicodeSearch {
const APP_NAME: &'static str = "furumusic";
const MIGRATION_NAME: &'static str = "m_0055_podcast_sync_unicode_search";
const DEPENDENCIES: &'static [migrations::MigrationDependency] =
&[migrations::MigrationDependency::migration(
"furumusic",
"m_0054_create_podcasts",
)];
const OPERATIONS: &'static [Operation] = &[Operation::custom(create_podcast_sync).build()];
}
pub const MIGRATIONS: &[&SyncDynMigration] = &[
&M0006CreateMediaFile,
&M0007CreateArtist,
@@ -2881,5 +2930,7 @@ pub mod db_migrations {
&M0050CreateMetadataFixHistory,
&M0051AddListenStatisticsIndexes,
&M0052AddImportPlaylistDestinations,
&M0054CreatePodcasts,
&M0055PodcastSyncAndUnicodeSearch,
];
}
+1
View File
@@ -332,6 +332,7 @@ 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>,
+28 -3
View File
@@ -1046,7 +1046,18 @@ impl PlayerDeviceHub {
.playback_state_by_user
.get(&playback_user_id)
.cloned()
.map(|playback_state| playback_state_at(playback_state, now))
.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
})
}
fn jam_dtos_locked(
@@ -1150,6 +1161,16 @@ 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}")
}
@@ -5467,7 +5488,7 @@ fn hex_value(byte: u8) -> Option<u8> {
}
}
fn parse_range(header: &str, file_size: u64) -> Option<(u64, u64)> {
pub(crate) fn parse_range(header: &str, file_size: u64) -> Option<(u64, u64)> {
if file_size == 0 {
return None;
}
@@ -6657,13 +6678,14 @@ 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(),
@@ -6968,6 +6990,9 @@ 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,
+515
View File
@@ -0,0 +1,515 @@
//! Server-owned podcast catalogue and cache; subscriptions and progress are personal.
pub(crate) mod sync;
mod web;
pub use web::PodcastApp;
use crate::{
config::AppConfig,
scheduler::{Job, JobContext, JobLog},
};
use anyhow::{Context, Result, bail};
use futures_util::StreamExt;
use music_dht::podcast::feed::parse_feed_with_base;
use music_dht::podcast::{
EpisodeMeta, FeedUrl, KnownEpisode, PodcastId, PodcastMeta, ShareRecord, SubscriptionRecord,
};
use music_dht::podcast_dht::{PodcastCardSpec, PodcastDht, PodcastShareState};
use serde_json::{Value, json};
use sqlx::{PgPool, Row};
use std::{net::IpAddr, path::PathBuf, time::Duration};
use tokio::io::AsyncWriteExt;
const MAX_FEED_BYTES: usize = 16 * 1024 * 1024;
const MAX_AUDIO_BYTES: u64 = 2 * 1024 * 1024 * 1024;
pub(crate) async fn search(
pool: &PgPool,
user: i64,
query: &str,
limit: i64,
) -> Result<Vec<Value>> {
let words: Vec<String> = query
.split_whitespace()
.take(20)
.map(|word| {
format!(
"%{}%",
word.replace('\\', "\\\\")
.replace('%', "\\%")
.replace('_', "\\_")
)
})
.collect();
if words.is_empty() {
return Ok(Vec::new());
}
Ok(sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'url',p.origin_url,'metadata',p.metadata,'subscribed',EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.user_id=$1 AND s.podcast_id=p.id)) FROM furumusic__podcast p WHERE EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id AND (s.user_id=$1 OR s.shared)) AND NOT EXISTS(SELECT 1 FROM unnest($2::text[]) AS term WHERE concat_ws(' ',p.metadata->>'title',p.metadata->>'description',p.metadata->>'author') COLLATE furumusic_unicode NOT ILIKE term) ORDER BY p.metadata->>'title',p.id LIMIT $3").bind(user).bind(words).bind(limit.clamp(1,100)).fetch_all(pool).await?)
}
fn public_address(ip: IpAddr) -> bool {
match ip {
IpAddr::V4(ip) => {
!(ip.is_private()
|| ip.is_loopback()
|| ip.is_link_local()
|| ip.is_unspecified()
|| ip.is_multicast()
|| ip.is_broadcast()
|| ip.octets()[0] == 0
|| ip.octets()[0] >= 240
|| (ip.octets()[0] == 100 && (64..=127).contains(&ip.octets()[1])))
}
IpAddr::V6(ip) => ip
.to_ipv4_mapped()
.map(|v| public_address(IpAddr::V4(v)))
.unwrap_or_else(|| (ip.segments()[0] & 0xe000) == 0x2000),
}
}
/// Resolve and pin public addresses on every redirect, including enclosure requests.
pub(super) async fn fetch(
url: &str,
range: Option<&str>,
validators: Option<(&str, &str)>,
) -> Result<reqwest::Response> {
let mut url = reqwest::Url::parse(FeedUrl::parse(url)?.as_str())?;
for _ in 0..8 {
let host = url.host_str().context("missing host")?;
let addresses: Vec<_> =
tokio::net::lookup_host((host, url.port_or_known_default().context("missing port")?))
.await?
.collect();
if addresses.is_empty() || addresses.iter().any(|a| !public_address(a.ip())) {
bail!("podcast sources must use public internet addresses");
}
let client = reqwest::Client::builder()
.no_proxy()
.redirect(reqwest::redirect::Policy::none())
.connect_timeout(Duration::from_secs(15))
.timeout(Duration::from_secs(600))
.user_agent(concat!("FuruMusic/", env!("CARGO_PKG_VERSION")))
.resolve_to_addrs(host, &addresses)
.build()?;
let mut request = client.get(url.clone());
if let Some(range) = range {
request = request.header("Range", range);
}
if let Some((etag, modified)) = validators {
if !etag.is_empty() {
request = request.header("If-None-Match", etag);
}
if !modified.is_empty() {
request = request.header("If-Modified-Since", modified);
}
}
let response = request
.send()
.await
.context("podcast source request failed")?;
if response.status() == reqwest::StatusCode::NOT_MODIFIED {
return Ok(response);
}
if response.status().is_redirection() {
url = url.join(
response
.headers()
.get("location")
.context("redirect without location")?
.to_str()?,
)?;
FeedUrl::parse(url.as_str())?;
continue;
}
return response
.error_for_status()
.context("podcast source returned an error");
}
bail!("too many podcast redirects")
}
async fn feed_bytes(response: reqwest::Response) -> Result<Vec<u8>> {
if response
.content_length()
.is_some_and(|len| len > MAX_FEED_BYTES as u64)
{
bail!("feed is too large");
}
let mut bytes = Vec::new();
let mut stream = response.bytes_stream();
while let Some(chunk) = stream.next().await {
let chunk = chunk?;
if bytes.len() + chunk.len() > MAX_FEED_BYTES {
bail!("feed is too large");
}
bytes.extend_from_slice(&chunk);
}
Ok(bytes)
}
pub(super) fn cache_path(config: &AppConfig, id: &str) -> PathBuf {
PathBuf::from(&config.agent_storage_dir)
.join("podcasts")
.join(blake3::hash(id.as_bytes()).to_hex().as_str())
}
pub(super) async fn subscribe(pool: &PgPool, user: i64, input: &str) -> Result<String> {
let origin = FeedUrl::from_user_input(input)?;
let existing: Option<String> =
sqlx::query_scalar("SELECT podcast_id FROM furumusic__podcast_alias WHERE url=$1")
.bind(origin.as_str())
.fetch_optional(pool)
.await?;
let id = if let Some(id) = existing {
id
} else {
let response = fetch(origin.as_str(), None, None).await?;
let final_url = FeedUrl::parse(response.url().as_str())?;
let bytes = feed_bytes(response).await?;
let feed = parse_feed_with_base(&bytes, Some(final_url.as_str()))?;
let mut tx = pool.begin().await?;
// Serialize identity resolution: two users subscribing via a redirect share one catalogue.
sqlx::query("SELECT pg_advisory_xact_lock(73829531)")
.execute(&mut *tx)
.await?;
let existing: Option<String> = sqlx::query_scalar(
"SELECT podcast_id FROM furumusic__podcast_alias WHERE url=$1 OR url=$2 LIMIT 1",
)
.bind(origin.as_str())
.bind(final_url.as_str())
.fetch_optional(&mut *tx)
.await?;
let id = existing.unwrap_or_else(|| PodcastId::from_feed_url(&origin).as_str().to_owned());
sqlx::query("INSERT INTO furumusic__podcast(id,origin_url,feed_url,metadata) VALUES($1,$2,$3,$4) ON CONFLICT(id) DO NOTHING")
.bind(&id).bind(origin.as_str()).bind(final_url.as_str()).bind(serde_json::to_value(feed.to_podcast_meta(final_url.clone()))?).execute(&mut *tx).await?;
for url in [&origin, &final_url] {
sqlx::query("INSERT INTO furumusic__podcast_alias(url,podcast_id) VALUES($1,$2) ON CONFLICT DO NOTHING").bind(url.as_str()).bind(&id).execute(&mut *tx).await?;
}
tx.commit().await?;
id
};
sqlx::query("INSERT INTO furumusic__podcast_subscription(user_id,podcast_id) VALUES($1,$2) ON CONFLICT DO NOTHING").bind(user).bind(&id).execute(pool).await?;
Ok(id)
}
pub(super) async fn refresh(pool: &PgPool, id: &str) -> Result<usize> {
let result = tokio::time::timeout(Duration::from_secs(60), refresh_inner(pool, id))
.await
.unwrap_or_else(|_| Err(anyhow::anyhow!("feed check timed out")));
if result.is_err() {
sqlx::query("UPDATE furumusic__podcast SET checked_at=now(),last_error='Feed check failed; retry later' WHERE id=$1").bind(id).execute(pool).await?;
}
result
}
async fn refresh_inner(pool: &PgPool, id: &str) -> Result<usize> {
let mut tx = pool.begin().await?;
sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1,7391))")
.bind(id)
.execute(&mut *tx)
.await?;
let row = sqlx::query("SELECT * FROM furumusic__podcast WHERE id=$1 FOR UPDATE")
.bind(id)
.fetch_one(&mut *tx)
.await?;
let url: String = row.get("feed_url");
let etag: Option<String> = row.get("etag");
let modified: Option<String> = row.get("modified");
let response = fetch(
&url,
None,
Some((
etag.as_deref().unwrap_or(""),
modified.as_deref().unwrap_or(""),
)),
)
.await?;
if response.status() == reqwest::StatusCode::NOT_MODIFIED {
sqlx::query("UPDATE furumusic__podcast SET checked_at=now(),last_error=NULL WHERE id=$1")
.bind(id)
.execute(&mut *tx)
.await?;
tx.commit().await?;
return Ok(0);
}
let final_url = FeedUrl::parse(response.url().as_str())?;
let etag = response
.headers()
.get("etag")
.and_then(|v| v.to_str().ok())
.map(str::to_owned);
let modified = response
.headers()
.get("last-modified")
.and_then(|v| v.to_str().ok())
.map(str::to_owned);
let bytes = feed_bytes(response).await?;
let feed = parse_feed_with_base(&bytes, Some(final_url.as_str()))?;
let podcast_id: PodcastId = serde_json::from_value(json!(id))?;
let stored: Vec<Value> =
sqlx::query_scalar("SELECT metadata FROM furumusic__podcast_episode WHERE podcast_id=$1")
.bind(id)
.fetch_all(&mut *tx)
.await?;
let known: Vec<_> = stored
.into_iter()
.map(serde_json::from_value::<EpisodeMeta>)
.collect::<std::result::Result<Vec<_>, _>>()?
.into_iter()
.map(|meta| KnownEpisode {
episode_id: meta.episode_id.clone(),
hints: meta.identity_hints(),
})
.collect();
let ids = feed.resolve_episode_ids(&podcast_id, &known);
let mut added = 0;
for (episode, episode_id) in feed.episodes.iter().zip(ids) {
let Some(episode_id) = episode_id else {
continue;
};
let meta = episode.to_meta(&podcast_id, episode_id.clone());
let inserted: bool = sqlx::query_scalar("INSERT INTO furumusic__podcast_episode(id,podcast_id,metadata) VALUES($1,$2,$3) ON CONFLICT(id) DO UPDATE SET metadata=EXCLUDED.metadata RETURNING (xmax=0)").bind(episode_id.as_str()).bind(id).bind(serde_json::to_value(meta)?).fetch_one(&mut *tx).await?;
added += usize::from(inserted);
sync::restore_episode_progress(&mut tx, episode_id.as_str()).await?;
}
for alias in [
Some(final_url.clone()),
feed.new_feed_url
.as_deref()
.and_then(|u| FeedUrl::parse(u).ok()),
]
.into_iter()
.flatten()
{
sqlx::query("INSERT INTO furumusic__podcast_alias(url,podcast_id) VALUES($1,$2) ON CONFLICT DO NOTHING").bind(alias.as_str()).bind(id).execute(&mut *tx).await?;
}
let next_url = feed
.new_feed_url
.as_deref()
.and_then(|u| FeedUrl::parse(u).ok())
.unwrap_or(final_url.clone());
let moved = next_url != final_url;
sqlx::query("UPDATE furumusic__podcast SET feed_url=$2,metadata=$3,etag=$4,modified=$5,checked_at=now(),last_error=NULL WHERE id=$1")
.bind(id).bind(next_url.as_str()).bind(serde_json::to_value(feed.to_podcast_meta(next_url.clone()))?).bind(if moved {None} else {etag}).bind(if moved {None} else {modified}).execute(&mut *tx).await?;
tx.commit().await?;
Ok(added)
}
pub(super) async fn download(
pool: &PgPool,
config: &AppConfig,
id: &str,
force: bool,
) -> Result<()> {
static DOWNLOADS: tokio::sync::Semaphore = tokio::sync::Semaphore::const_new(3);
let _permit = DOWNLOADS.acquire().await?;
let podcast: Option<String> =
sqlx::query_scalar("SELECT podcast_id FROM furumusic__podcast_episode WHERE id=$1")
.bind(id)
.fetch_optional(pool)
.await?;
let Some(podcast) = podcast else {
return Ok(());
};
let mut cache_guard = pool.begin().await?;
sqlx::query("SELECT pg_advisory_xact_lock_shared(hashtextextended($1,7421))")
.bind(&podcast)
.execute(&mut *cache_guard)
.await?;
let meta: Option<Value> = sqlx::query_scalar("UPDATE furumusic__podcast_episode SET download_until=now()+interval '15 minutes',download_error=NULL WHERE id=$1 AND cached_at IS NULL AND (download_until IS NULL OR download_until<now()) AND ($2 OR (NOT expired AND (retry_at IS NULL OR retry_at<now()))) RETURNING metadata")
.bind(id).bind(force).fetch_optional(pool).await?;
let Some(meta) = meta else { return Ok(()) };
let meta: EpisodeMeta = serde_json::from_value(meta)?;
let path = cache_path(config, id);
let temporary = path.with_extension("part");
let result: Result<()> = tokio::time::timeout(Duration::from_secs(12 * 60), async {
tokio::fs::create_dir_all(path.parent().context("missing cache directory")?).await?;
let response = fetch(&meta.audio_url, None, None).await?;
if response.content_length().is_some_and(|len| len > MAX_AUDIO_BYTES) { bail!("episode exceeds 2 GiB limit"); }
let expected = response.content_length();
let mut stream = response.bytes_stream();
let mut file = tokio::fs::File::create(&temporary).await?;
let mut length = 0;
while let Some(chunk) = stream.next().await {
let chunk = chunk?;
length += chunk.len() as u64;
if length > MAX_AUDIO_BYTES { bail!("episode exceeds 2 GiB limit"); }
file.write_all(&chunk).await?;
}
if length == 0 || expected.is_some_and(|size| size != length) { bail!("incomplete episode download"); }
file.flush().await?;
drop(file);
tokio::fs::rename(&temporary, &path).await?;
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=now(),download_until=NULL,retry_at=NULL,download_error=NULL,expired=false WHERE id=$1").bind(id).execute(pool).await?;
Ok(())
}).await.unwrap_or_else(|_| Err(anyhow::anyhow!("episode download timed out")));
if result.is_err() {
let _ = tokio::fs::remove_file(&temporary).await;
sqlx::query("UPDATE furumusic__podcast_episode SET download_until=NULL,retry_at=now()+interval '30 minutes',download_error='Download failed; will retry' WHERE id=$1").bind(id).execute(pool).await?;
}
result
}
pub(super) async fn download_pending(
pool: &PgPool,
config: &AppConfig,
podcast: Option<&str>,
) -> Result<()> {
let ids: Vec<String> = sqlx::query_scalar("SELECT e.id FROM furumusic__podcast_episode e WHERE cached_at IS NULL AND NOT expired AND ($1::text IS NULL OR podcast_id=$1) AND EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.podcast_id=e.podcast_id) AND (retry_at IS NULL OR retry_at<now()) ORDER BY discovered_at DESC LIMIT 100").bind(podcast).fetch_all(pool).await?;
futures_util::stream::iter(ids)
.for_each_concurrent(3, |id| async move {
let _ = download(pool, config, &id, false).await;
})
.await;
Ok(())
}
pub async fn reconcile(pool: &PgPool, overlay: &PodcastDht) -> Result<()> {
// Read the desired set only after acquiring the gate. An older pass must
// never publish its snapshot after a completed share-off/unsubscribe pass.
static GATE: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
let _guard = GATE.lock().await;
let rows = sqlx::query("SELECT p.*,s.confirmed_urls,s.user_id FROM furumusic__podcast p JOIN furumusic__podcast_subscription s ON s.podcast_id=p.id WHERE s.shared ORDER BY p.id").fetch_all(pool).await?;
let mut states = std::collections::BTreeMap::new();
for row in rows {
if !sync::publication_current(pool, row.get("user_id")).await? {
continue;
}
let id: String = row.get("id");
let meta: PodcastMeta = serde_json::from_value(row.get("metadata"))?;
let origin = FeedUrl::parse(row.get::<&str, _>("origin_url"))?;
let sub = SubscriptionRecord {
podcast_id: serde_json::from_value(json!(id))?,
subscribed: true,
podcast: meta,
feed_aliases: vec![origin],
generation: 1,
hlc_ms: 1,
op_id: "web-subscription".into(),
};
let card = PodcastCardSpec::from_subscription(&sub)?;
let confirmed: Option<Value> = row.get("confirmed_urls");
if !card.privacy_warnings().is_empty()
&& confirmed != Some(json!([card.feed_url, card.id_feed_url]))
{
continue;
}
let share = ShareRecord {
podcast_id: sub.podcast_id.clone(),
shared: true,
generation: 2,
hlc_ms: 2,
op_id: "web-share".into(),
};
states.insert(
id,
PodcastShareState {
subscription: sub,
share: Some(share),
card: Some(card),
privacy_confirmed: true,
},
);
}
overlay.sync_shares(states.into_values().collect()).await?;
Ok(())
}
pub struct PodcastRefreshJob;
#[async_trait::async_trait]
impl Job for PodcastRefreshJob {
fn name(&self) -> &'static str {
"podcast_refresh"
}
fn description(&self) -> &'static str {
"Check subscribed podcast feeds, download episodes and enforce cache retention"
}
fn default_cron(&self) -> &'static str {
"0 */30 * * * *"
}
async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> Result<()> {
let ids: Vec<String> =
sqlx::query_scalar("SELECT DISTINCT podcast_id FROM furumusic__podcast_subscription")
.fetch_all(&ctx.pool)
.await?;
let mut failed = 0;
for id in &ids {
if refresh(&ctx.pool, id).await.is_err() {
failed += 1;
sqlx::query("UPDATE furumusic__podcast SET last_error='Feed check failed',checked_at=now() WHERE id=$1").bind(id).execute(&ctx.pool).await?;
}
}
download_pending(&ctx.pool, &ctx.config, None).await?;
cleanup(&ctx.pool, &ctx.config).await?;
let _ = crate::federation::handle().sync_podcasts().await;
log.info(&format!(
"Checked {} podcast feeds; {} failed",
ids.len(),
failed
));
Ok(())
}
}
async fn cleanup(pool: &PgPool, config: &AppConfig) -> Result<()> {
let days: Option<i32> =
sqlx::query_scalar("SELECT retention_days FROM furumusic__podcast_settings WHERE id=1")
.fetch_one(pool)
.await?;
let Some(days) = days else { return Ok(()) };
let rows = sqlx::query(
"SELECT id,podcast_id FROM furumusic__podcast_episode WHERE cached_at<now()-make_interval(days=>$1)",
)
.bind(days)
.fetch_all(pool)
.await?;
for row in rows {
let id: String = row.get("id");
let podcast: String = row.get("podcast_id");
let mut tx = pool.begin().await?;
let locked: bool =
sqlx::query_scalar("SELECT pg_try_advisory_xact_lock(hashtextextended($1,7421))")
.bind(&podcast)
.fetch_one(&mut *tx)
.await?;
if !locked {
continue;
}
let expired: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__podcast_episode WHERE id=$1 AND cached_at<now()-make_interval(days=>$2))").bind(&id).bind(days).fetch_one(&mut *tx).await?;
if !expired {
continue;
}
match tokio::fs::remove_file(cache_path(config, &id)).await {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(_) => continue,
}
sqlx::query(
"UPDATE furumusic__podcast_episode SET cached_at=NULL,expired=true WHERE id=$1",
)
.bind(id)
.execute(&mut *tx)
.await?;
tx.commit().await?;
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn blocks_non_public_sources() {
for ip in [
"127.0.0.1",
"10.1.1.1",
"169.254.169.254",
"100.64.0.1",
"::1",
"::ffff:127.0.0.1",
"fc00::1",
] {
assert!(!public_address(ip.parse().unwrap()), "{ip}");
}
assert!(public_address("8.8.8.8".parse().unwrap()));
}
}
+32
View File
@@ -0,0 +1,32 @@
CREATE TABLE IF NOT EXISTS furumusic__podcast (
id TEXT PRIMARY KEY, origin_url TEXT NOT NULL UNIQUE, feed_url TEXT NOT NULL,
metadata JSONB NOT NULL, etag TEXT, modified TEXT, checked_at TIMESTAMPTZ,
last_error TEXT, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE TABLE IF NOT EXISTS furumusic__podcast_alias (
url TEXT PRIMARY KEY, podcast_id TEXT NOT NULL REFERENCES furumusic__podcast(id) ON DELETE CASCADE
);
CREATE TABLE IF NOT EXISTS furumusic__podcast_subscription (
user_id BIGINT NOT NULL REFERENCES furumusic__user(id) ON DELETE CASCADE,
podcast_id TEXT NOT NULL REFERENCES furumusic__podcast(id) ON DELETE CASCADE,
shared BOOLEAN NOT NULL DEFAULT false, confirmed_urls JSONB,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY(user_id,podcast_id)
);
CREATE TABLE IF NOT EXISTS furumusic__podcast_episode (
id TEXT PRIMARY KEY, podcast_id TEXT NOT NULL REFERENCES furumusic__podcast(id) ON DELETE CASCADE,
metadata JSONB NOT NULL, discovered_at TIMESTAMPTZ NOT NULL DEFAULT now(),
cached_at TIMESTAMPTZ, download_until TIMESTAMPTZ, retry_at TIMESTAMPTZ,
download_error TEXT, expired BOOLEAN NOT NULL DEFAULT false
);
CREATE INDEX IF NOT EXISTS idx_podcast_episode_feed ON furumusic__podcast_episode(podcast_id);
CREATE TABLE IF NOT EXISTS furumusic__podcast_progress (
user_id BIGINT NOT NULL REFERENCES furumusic__user(id) ON DELETE CASCADE,
episode_id TEXT NOT NULL REFERENCES furumusic__podcast_episode(id) ON DELETE CASCADE,
position_ms BIGINT NOT NULL DEFAULT 0, completed BOOLEAN NOT NULL DEFAULT false,
generation BIGINT NOT NULL DEFAULT 0, checkpoint BIGINT NOT NULL DEFAULT 0,
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY(user_id,episode_id)
);
CREATE TABLE IF NOT EXISTS furumusic__podcast_settings (
id INTEGER PRIMARY KEY CHECK(id=1), retention_days INTEGER CHECK(retention_days BETWEEN 1 AND 36500)
);
INSERT INTO furumusic__podcast_settings(id) VALUES(1) ON CONFLICT DO NOTHING;
+448
View File
@@ -0,0 +1,448 @@
//! Durable Frid podcast registers. Projections are user-scoped; revocations
//! remain here after a subscription is removed from the visible catalogue.
use super::*;
use music_dht::device_sync::{SyncOpPayload, SyncOpWire, SyncSnapshot};
use music_dht::podcast::{
ListenSession, ProgressRecord, ProgressStatus, effective_share, merge_listen_session,
merge_progress, merge_share, merge_subscription, next_podcast_generation,
};
use serde::{Serialize, de::DeserializeOwned};
use sqlx::{Postgres, Transaction};
fn current_users() -> &'static std::sync::Mutex<std::collections::HashSet<i64>> {
static USERS: std::sync::OnceLock<std::sync::Mutex<std::collections::HashSet<i64>>> =
std::sync::OnceLock::new();
USERS.get_or_init(Default::default)
}
pub async fn publication_current(pool: &PgPool, user: i64) -> Result<bool> {
if current_users()
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.contains(&user)
{
return Ok(true);
}
let peers:bool=sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__fed_device d WHERE user_id=$1 AND trusted_at_ms IS NOT NULL AND revoked_at_ms IS NULL AND protocol_version>=4 AND device_id<>(SELECT device_id FROM furumusic__fed_device_identity WHERE user_id=$1))").bind(user).fetch_one(pool).await?;
Ok(!peers)
}
pub async fn exchange_complete(pool: &PgPool, user: i64, peer: &str) -> Result<()> {
let version: Option<i32> = sqlx::query_scalar(
"SELECT protocol_version FROM furumusic__fed_device WHERE user_id=$1 AND device_id=$2",
)
.bind(user)
.bind(peer)
.fetch_optional(pool)
.await?;
if version.is_some_and(|v| v >= 4) {
current_users()
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.insert(user);
refresh_received(pool.clone());
tokio::spawn(async {
let _ = crate::federation::handle().sync_podcasts().await;
});
}
Ok(())
}
async fn get<T: DeserializeOwned>(
tx: &mut Transaction<'_, Postgres>,
user: i64,
kind: &str,
id: &str,
) -> Result<Option<T>> {
let value: Option<Value> = sqlx::query_scalar("SELECT value FROM furumusic__podcast_register WHERE user_id=$1 AND kind=$2 AND entity_id=$3").bind(user).bind(kind).bind(id).fetch_optional(&mut **tx).await?;
Ok(value.map(serde_json::from_value).transpose()?)
}
async fn put<T: Serialize>(
tx: &mut Transaction<'_, Postgres>,
user: i64,
kind: &str,
id: &str,
value: &T,
) -> Result<()> {
sqlx::query("INSERT INTO furumusic__podcast_register(user_id,kind,entity_id,value) VALUES($1,$2,$3,$4) ON CONFLICT(user_id,kind,entity_id) DO UPDATE SET value=EXCLUDED.value").bind(user).bind(kind).bind(id).bind(serde_json::to_value(value)?).execute(&mut **tx).await?;
Ok(())
}
async fn begin(pool: &PgPool, user: i64) -> Result<Transaction<'_, Postgres>> {
let mut tx = pool.begin().await?;
sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1,7512))")
.bind(format!("podcast-sync:{user}"))
.execute(&mut *tx)
.await?;
Ok(tx)
}
async fn project_subscription(
tx: &mut Transaction<'_, Postgres>,
user: i64,
id: &str,
) -> Result<()> {
let Some(sub) = get::<SubscriptionRecord>(tx, user, "subscription", id).await? else {
return Ok(());
};
let share = get::<ShareRecord>(tx, user, "share", id).await?;
let origin = sub
.feed_urls()
.into_iter()
.find(|url| PodcastId::from_feed_url(url) == sub.podcast_id)
.unwrap_or(sub.podcast.feed_url.clone());
sqlx::query("INSERT INTO furumusic__podcast(id,origin_url,feed_url,metadata) VALUES($1,$2,$3,$4) ON CONFLICT(id) DO UPDATE SET origin_url=EXCLUDED.origin_url").bind(id).bind(origin.as_str()).bind(sub.podcast.feed_url.as_str()).bind(json!(sub.podcast)).execute(&mut **tx).await?;
for alias in sub.feed_urls() {
sqlx::query("INSERT INTO furumusic__podcast_alias(url,podcast_id) VALUES($1,$2) ON CONFLICT DO NOTHING").bind(alias.as_str()).bind(id).execute(&mut **tx).await?;
}
if sub.subscribed {
let shared = effective_share(Some(&sub), share.as_ref());
sqlx::query("INSERT INTO furumusic__podcast_subscription(user_id,podcast_id,shared) VALUES($1,$2,$3) ON CONFLICT(user_id,podcast_id) DO UPDATE SET shared=EXCLUDED.shared,confirmed_urls=CASE WHEN EXCLUDED.shared THEN furumusic__podcast_subscription.confirmed_urls ELSE NULL END").bind(user).bind(id).bind(shared).execute(&mut **tx).await?;
} else {
sqlx::query(
"DELETE FROM furumusic__podcast_subscription WHERE user_id=$1 AND podcast_id=$2",
)
.bind(user)
.bind(id)
.execute(&mut **tx)
.await?;
}
Ok(())
}
async fn merge_sub(
tx: &mut Transaction<'_, Postgres>,
user: i64,
incoming: SubscriptionRecord,
) -> Result<()> {
incoming.validate()?;
let id = incoming.podcast_id.as_str();
let mut merged = match get::<SubscriptionRecord>(tx, user, "subscription", id).await? {
Some(current) => merge_subscription(&current, &incoming)?,
None => incoming.clone(),
};
if let Some(aliases) = get::<Vec<FeedUrl>>(tx, user, "aliases", id).await? {
merged.add_feed_aliases(&aliases);
}
put(tx, user, "subscription", id, &merged).await?;
project_subscription(tx, user, id).await
}
async fn merge_shared(
tx: &mut Transaction<'_, Postgres>,
user: i64,
incoming: ShareRecord,
local: bool,
) -> Result<()> {
let id = incoming.podcast_id.as_str();
let current = get::<ShareRecord>(tx, user, "share", id).await?;
let merged = match &current {
Some(current) => merge_share(current, &incoming)?,
None => incoming.clone(),
};
if !local && current.as_ref().map(|r| r.op_id.as_str()) != Some(merged.op_id.as_str()) {
sqlx::query("UPDATE furumusic__podcast_subscription SET confirmed_urls=NULL WHERE user_id=$1 AND podcast_id=$2").bind(user).bind(id).execute(&mut **tx).await?;
}
put(tx, user, "share", id, &merged).await?;
project_subscription(tx, user, id).await
}
async fn merge_resume(
tx: &mut Transaction<'_, Postgres>,
user: i64,
incoming: ProgressRecord,
) -> Result<()> {
incoming.validate()?;
let id = incoming.episode_id.as_str();
let merged = match get::<ProgressRecord>(tx, user, "progress", id).await? {
Some(current) => merge_progress(&current, &incoming)?,
None => incoming.clone(),
};
put(tx, user, "progress", id, &merged).await?;
project_resume(tx, user, &merged).await
}
async fn project_resume(
tx: &mut Transaction<'_, Postgres>,
user: i64,
record: &ProgressRecord,
) -> Result<()> {
sqlx::query("INSERT INTO furumusic__podcast_progress(user_id,episode_id,position_ms,completed,generation,checkpoint) SELECT $1,id,$3,$4,$5,0 FROM furumusic__podcast_episode WHERE id=$2 ON CONFLICT(user_id,episode_id) DO UPDATE SET position_ms=EXCLUDED.position_ms,completed=EXCLUDED.completed,generation=EXCLUDED.generation").bind(user).bind(record.episode_id.as_str()).bind(record.position_ms).bind(record.status==ProgressStatus::Completed).bind(record.generation.min(i64::MAX as u64) as i64).execute(&mut **tx).await?;
Ok(())
}
async fn merge_session(
tx: &mut Transaction<'_, Postgres>,
user: i64,
incoming: ListenSession,
) -> Result<()> {
incoming.validate()?;
let id = &incoming.session_id;
let merged = match get::<ListenSession>(tx, user, "session", id).await? {
Some(current) => merge_listen_session(&current, &incoming)?,
None => incoming.clone(),
};
put(tx, user, "session", id, &merged).await
}
/// Applying the same operation again is safe, including after a crash between
/// persisting its log entry and updating the projection.
pub async fn apply_op(pool: &PgPool, user: i64, op: &SyncOpWire) -> Result<bool> {
let mut tx = begin(pool, user).await?;
apply_op_tx(&mut tx, user, op).await?;
tx.commit().await?;
Ok(true)
}
pub(crate) async fn apply_op_tx(
tx: &mut Transaction<'_, Postgres>,
user: i64,
op: &SyncOpWire,
) -> Result<bool> {
op.validate_podcast()?;
let reference = match &op.payload {
SyncOpPayload::PodcastProgressSet { episode, .. }
| SyncOpPayload::PodcastListenRecorded { episode, .. } => episode.as_ref(),
_ => None,
};
if let Some(reference) = reference {
materialize_reference(tx, reference).await?;
}
if let Some(sub) = op.podcast_subscription() {
merge_sub(tx, user, sub).await?;
} else if let Some(share) = op.podcast_share() {
let local:bool=sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__fed_device_identity WHERE user_id=$1 AND device_id=$2)").bind(user).bind(&op.origin_device_id).fetch_one(&mut **tx).await?;
merge_shared(tx, user, share, local).await?;
} else if let Some((id, aliases)) = op.podcast_feed_aliases() {
let current = get::<Vec<FeedUrl>>(tx, user, "aliases", id.as_str())
.await?
.unwrap_or_default();
let merged = music_dht::podcast::merge_feed_aliases(id, &current, aliases);
put(tx, user, "aliases", id.as_str(), &merged).await?;
if let Some(mut sub) =
get::<SubscriptionRecord>(tx, user, "subscription", id.as_str()).await?
{
sub.add_feed_aliases(aliases);
put(tx, user, "subscription", id.as_str(), &sub).await?;
project_subscription(tx, user, id.as_str()).await?;
}
} else if let Some(progress) = op.podcast_progress() {
merge_resume(tx, user, progress).await?;
} else if let Some(session) = op.podcast_listen_session() {
merge_session(tx, user, session.clone()).await?;
}
Ok(true)
}
async fn materialize_reference(
tx: &mut Transaction<'_, Postgres>,
reference: &music_dht::podcast::PodcastEpisodeRef,
) -> Result<()> {
reference.validate()?;
let podcast = PodcastMeta {
feed_url: reference.feed_url.clone(),
title: reference.podcast_title.clone(),
author: None,
description: None,
link: None,
image_url: reference.image_url.clone(),
};
sqlx::query("INSERT INTO furumusic__podcast(id,origin_url,feed_url,metadata) VALUES($1,$2,$2,$3) ON CONFLICT DO NOTHING").bind(reference.podcast_id.as_str()).bind(reference.feed_url.as_str()).bind(json!(podcast)).execute(&mut **tx).await?;
let episode = EpisodeMeta {
episode_id: reference.episode_id.clone(),
podcast_id: reference.podcast_id.clone(),
guid: None,
title: reference.episode_title.clone(),
description: None,
season: reference.season,
episode_number: reference.episode_number,
episode_type: music_dht::podcast::EpisodeType::Full,
published_at_ms: reference.published_at_ms,
duration_ms: reference.duration_ms,
audio_url: reference.audio_url.clone(),
mime: reference.mime.clone(),
byte_len: None,
image_url: reference.image_url.clone(),
link: None,
};
sqlx::query("INSERT INTO furumusic__podcast_episode(id,podcast_id,metadata) VALUES($1,$2,$3) ON CONFLICT DO NOTHING").bind(reference.episode_id.as_str()).bind(reference.podcast_id.as_str()).bind(json!(episode)).execute(&mut **tx).await?;
Ok(())
}
pub async fn apply_snapshot(pool: &PgPool, user: i64, snapshot: &SyncSnapshot) -> Result<()> {
if !snapshot.podcast_state_within_limits() {
bail!("podcast snapshot exceeds contract limits");
}
let mut tx = begin(pool, user).await?;
for sub in &snapshot.podcast_subscriptions {
merge_sub(&mut tx, user, sub.clone()).await?;
}
for share in &snapshot.podcast_shares {
merge_shared(&mut tx, user, share.clone(), false).await?;
}
for progress in &snapshot.podcast_progress {
merge_resume(&mut tx, user, progress.clone()).await?;
}
for session in &snapshot.podcast_listen_sessions {
merge_session(&mut tx, user, session.clone()).await?;
}
tx.commit().await?;
Ok(())
}
pub async fn append_snapshot(pool: &PgPool, user: i64, snapshot: &mut SyncSnapshot) -> Result<()> {
seed_user(pool, user).await?;
let rows = sqlx::query(
"SELECT kind,value FROM furumusic__podcast_register WHERE user_id=$1 ORDER BY entity_id",
)
.bind(user)
.fetch_all(pool)
.await?;
for row in rows {
let value: Value = row.get("value");
match row.get::<&str, _>("kind") {
"subscription" => snapshot
.podcast_subscriptions
.push(serde_json::from_value(value)?),
"share" => snapshot.podcast_shares.push(serde_json::from_value(value)?),
"progress" => snapshot
.podcast_progress
.push(serde_json::from_value(value)?),
"session" => snapshot
.podcast_listen_sessions
.push(serde_json::from_value(value)?),
_ => {}
}
}
snapshot.bound_podcast_state();
Ok(())
}
pub async fn local_subscription(
pool: &PgPool,
user: i64,
id: &str,
subscribed: bool,
) -> Result<()> {
let mut tx = begin(pool, user).await?;
let sub = get::<SubscriptionRecord>(&mut tx, user, "subscription", id).await?;
let share = get::<ShareRecord>(&mut tx, user, "share", id).await?;
let generation = next_podcast_generation(sub.as_ref(), share.as_ref());
let row = sqlx::query("SELECT metadata,origin_url FROM furumusic__podcast WHERE id=$1")
.bind(id)
.fetch_one(&mut *tx)
.await?;
let podcast: PodcastMeta = serde_json::from_value(row.get("metadata"))?;
let origin = FeedUrl::parse(row.get::<&str, _>("origin_url"))?;
let mut aliases = sub.as_ref().map(|s| s.feed_urls()).unwrap_or_default();
aliases.push(origin);
let podcast_id: PodcastId = serde_json::from_value(json!(id))?;
let aliases = music_dht::podcast::merge_feed_aliases(&podcast_id, &[], &aliases);
tx.commit().await?;
crate::federation::devices::record_podcast_op(
pool,
user,
SyncOpPayload::PodcastSubscriptionSet {
podcast_id,
subscribed,
podcast,
feed_aliases: aliases,
generation,
},
)
.await?;
if !subscribed {
local_share(pool, user, id, false).await?;
}
Ok(())
}
pub async fn local_share(pool: &PgPool, user: i64, id: &str, shared: bool) -> Result<()> {
let mut tx = begin(pool, user).await?;
let sub = get::<SubscriptionRecord>(&mut tx, user, "subscription", id).await?;
let share = get::<ShareRecord>(&mut tx, user, "share", id).await?;
let generation = next_podcast_generation(sub.as_ref(), share.as_ref());
tx.commit().await?;
crate::federation::devices::record_podcast_op(
pool,
user,
SyncOpPayload::PodcastShareSet {
podcast_id: serde_json::from_value(json!(id))?,
shared,
generation,
},
)
.await
}
pub async fn seed_user(pool: &PgPool, user: i64) -> Result<()> {
let rows=sqlx::query("SELECT s.podcast_id,s.shared FROM furumusic__podcast_subscription s WHERE user_id=$1 AND NOT EXISTS(SELECT 1 FROM furumusic__podcast_register r WHERE r.user_id=s.user_id AND r.entity_id=s.podcast_id AND r.kind='subscription')").bind(user).fetch_all(pool).await?;
for row in rows {
let id: String = row.get("podcast_id");
let shared: bool = row.get("shared");
local_subscription(pool, user, &id, true).await?;
if shared {
local_share(pool, user, &id, true).await?;
}
}
Ok(())
}
pub async fn ensure_subscribed(pool: &PgPool, user: i64, id: &str) -> Result<()> {
let active:bool=sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__podcast_register WHERE user_id=$1 AND kind='subscription' AND entity_id=$2 AND value->>'subscribed'='true')").bind(user).bind(id).fetch_one(pool).await?;
if !active {
local_subscription(pool, user, id, true).await?;
}
Ok(())
}
pub async fn local_progress(
pool: &PgPool,
user: i64,
id: &str,
generation: u64,
position: i64,
completed: bool,
) -> Result<()> {
let row=sqlx::query("SELECT g.*,e.metadata AS episode,p.metadata AS podcast FROM furumusic__podcast_progress g JOIN furumusic__podcast_episode e ON e.id=g.episode_id JOIN furumusic__podcast p ON p.id=e.podcast_id WHERE g.user_id=$1 AND g.episode_id=$2").bind(user).bind(id).fetch_one(pool).await?;
let episode: EpisodeMeta = serde_json::from_value(row.get("episode"))?;
let podcast: PodcastMeta = serde_json::from_value(row.get("podcast"))?;
crate::federation::devices::record_podcast_op(
pool,
user,
SyncOpPayload::PodcastProgressSet {
episode_id: episode.episode_id.clone(),
podcast_id: episode.podcast_id.clone(),
position_ms: position,
status: if completed {
ProgressStatus::Completed
} else if position > 0 {
ProgressStatus::InProgress
} else {
ProgressStatus::NotStarted
},
generation,
session_id: format!("web:{user}:{id}:{generation}"),
episode: Some(episode.to_ref(&podcast)),
},
)
.await
}
pub async fn restore_episode_progress(tx: &mut Transaction<'_, Postgres>, id: &str) -> Result<()> {
let rows=sqlx::query("SELECT user_id,value FROM furumusic__podcast_register WHERE kind='progress' AND entity_id=$1").bind(id).fetch_all(&mut **tx).await?;
for row in rows {
project_resume(
tx,
row.get("user_id"),
&serde_json::from_value(row.get("value"))?,
)
.await?;
}
Ok(())
}
pub fn refresh_received(pool: PgPool) {
static WORKER: tokio::sync::Semaphore = tokio::sync::Semaphore::const_new(1);
let Ok(permit) = WORKER.try_acquire() else {
return;
};
tokio::spawn(async move {
let _permit = permit;
let ids:Vec<String>=sqlx::query_scalar("SELECT DISTINCT p.id FROM furumusic__podcast p JOIN furumusic__podcast_subscription s ON s.podcast_id=p.id WHERE p.checked_at IS NULL LIMIT 20").fetch_all(&pool).await.unwrap_or_default();
for id in ids {
let _ = refresh(&pool, &id).await;
}
});
}
+6
View File
@@ -0,0 +1,6 @@
CREATE TABLE IF NOT EXISTS furumusic__podcast_register (
user_id BIGINT NOT NULL REFERENCES furumusic__user(id) ON DELETE CASCADE,
kind TEXT NOT NULL, entity_id TEXT NOT NULL, value JSONB NOT NULL,
PRIMARY KEY(user_id,kind,entity_id)
);
CREATE COLLATION IF NOT EXISTS furumusic_unicode (provider=icu, locale='und', deterministic=true);
+402
View File
@@ -0,0 +1,402 @@
use super::*;
use cot::Template;
#[test]
fn episode_routes_accept_encoded_colons_and_reject_invalid_ids() {
let id = format!("ep1:{}", "a".repeat(52));
assert_eq!(episode_path_id(&id).unwrap().as_str(), id);
assert_eq!(
episode_path_id(&id.replace(':', "%3A")).unwrap().as_str(),
id
);
assert_eq!(
episode_path_id(&id.replace(':', "%3a")).unwrap().as_str(),
id
);
assert!(episode_path_id("../private").is_err());
}
#[test]
fn renders_podcast_navigation_and_views() {
let html = crate::player::PlayerPageTemplate {
t: crate::i18n::Translations::for_lang(crate::i18n::Lang::En),
guest: false,
share_token: String::new(),
downloads_enabled: true,
torrent_downloads_enabled: true,
youtube_downloads_enabled: true,
}
.render()
.unwrap();
assert_eq!(
html.matches("@click=\"$store.podcasts.enter()\"").count(),
2
);
assert!(html.contains("/api/podcasts/action"));
assert!(
html.find("Alpine.store('podcasts',").unwrap()
< html.find("Alpine.store('library',").unwrap(),
"podcast navigation must be registered before library.init restores the hash"
);
if std::env::var_os("FURU_PODCAST_RENDER_FIXTURE").is_some() {
std::fs::write("target/podcast-player-fixture.html", html).unwrap();
}
}
#[tokio::test]
#[ignore = "requires FURU_PODCAST_TEST_DATABASE_URL pointing to a disposable PostgreSQL database"]
async fn postgres_multiuser_progress_retention_and_admin() {
let url = std::env::var("FURU_PODCAST_TEST_DATABASE_URL").expect("disposable database URL");
let admin_pool = PgPool::connect(&url).await.unwrap();
let schema = format!("podcast_test_{}", uuid::Uuid::new_v4().simple());
sqlx::query(&format!("CREATE SCHEMA {schema}"))
.execute(&admin_pool)
.await
.unwrap();
let search_path = format!("SET search_path TO {schema}");
let pool = sqlx::postgres::PgPoolOptions::new()
.max_connections(8)
.after_connect(move |connection, _| {
let query = search_path.clone();
Box::pin(async move {
sqlx::query(&query).execute(connection).await?;
Ok(())
})
})
.connect(&url)
.await
.unwrap();
sqlx::query("CREATE TABLE furumusic__user(id BIGINT PRIMARY KEY)")
.execute(&pool)
.await
.unwrap();
for statement in include_str!("schema.sql")
.split(';')
.filter(|s| !s.trim().is_empty())
{
sqlx::query(statement).execute(&pool).await.unwrap();
}
// Repeatability matters for partially applied upgrades.
for statement in include_str!("schema.sql")
.split(';')
.filter(|s| !s.trim().is_empty())
{
sqlx::query(statement).execute(&pool).await.unwrap();
}
sqlx::query("INSERT INTO furumusic__user VALUES(1),(2)")
.execute(&pool)
.await
.unwrap();
for source in [
include_str!("sync_schema.sql"),
include_str!("../../tests/podcast_sync_fixture.sql"),
] {
for statement in source.split(';').filter(|s| !s.trim().is_empty()) {
sqlx::query(statement).execute(&pool).await.unwrap();
}
}
let origin = FeedUrl::parse("https://example.test/feed.xml").unwrap();
let podcast = PodcastId::from_feed_url(&origin);
let feed=parse_feed_with_base(br#"<rss><channel><title>Fixture</title><item><title>Episode</title><guid>one</guid><enclosure url="https://example.test/audio.mp3"/></item></channel></rss>"#,Some(origin.as_str())).unwrap();
let episode = feed.episodes[0].to_meta(
&podcast,
feed.resolve_episode_ids(&podcast, &[])[0].clone().unwrap(),
);
if std::env::var_os("FURU_PODCAST_RENDER_FIXTURE").is_some() {
std::fs::write("target/podcast-feed-fixture.json",json!({"id":podcast,"metadata":feed.to_podcast_meta(origin.clone()),"episode":episode,"cache_name":blake3::hash(episode.episode_id.as_str().as_bytes()).to_hex().to_string()}).to_string()).unwrap();
}
sqlx::query(
"INSERT INTO furumusic__podcast(id,origin_url,feed_url,metadata) VALUES($1,$2,$2,$3)",
)
.bind(podcast.as_str())
.bind(origin.as_str())
.bind(json!(feed.to_podcast_meta(origin.clone())))
.execute(&pool)
.await
.unwrap();
sqlx::query("INSERT INTO furumusic__podcast_subscription(user_id,podcast_id,shared) VALUES(1,$1,true),(2,$1,false)").bind(podcast.as_str()).execute(&pool).await.unwrap();
sqlx::query("INSERT INTO furumusic__podcast_episode(id,podcast_id,metadata) VALUES($1,$2,$3)")
.bind(episode.episode_id.as_str())
.bind(podcast.as_str())
.bind(json!(episode))
.execute(&pool)
.await
.unwrap();
let directory =
std::env::temp_dir().join(format!("furumusic-podcast-test-{}", uuid::Uuid::new_v4()));
let config = AppConfig {
agent_storage_dir: directory.to_string_lossy().into_owned(),
..AppConfig::default()
};
let media = cache_path(&config, episode.episode_id.as_str());
tokio::fs::create_dir_all(media.parent().unwrap())
.await
.unwrap();
tokio::fs::write(&media, b"saved episode").await.unwrap();
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=now()")
.execute(&pool)
.await
.unwrap();
let range_request = Request::builder()
.header("range", "bytes=0-4")
.body(Body::empty())
.unwrap();
let response = super::media(
&pool,
&config,
2,
episode.episode_id.as_str(),
&range_request,
)
.await
.unwrap();
assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
assert_eq!(response.headers()["content-range"], "bytes 0-4/13");
assert_eq!(
response.into_body().into_bytes().await.unwrap().as_ref(),
b"saved"
);
let invalid_request = Request::builder()
.header("range", "bytes=900-1000")
.body(Body::empty())
.unwrap();
assert_eq!(
super::media(
&pool,
&config,
2,
episode.episode_id.as_str(),
&invalid_request
)
.await
.unwrap()
.status(),
StatusCode::RANGE_NOT_SATISFIABLE
);
assert!(
super::media(
&pool,
&config,
99,
episode.episode_id.as_str(),
&range_request
)
.await
.is_err()
);
assert_eq!(
list(&pool, 2, false).await.unwrap()["public"]
.as_array()
.unwrap()
.len(),
1
);
let request = |value| serde_json::from_value::<Action>(value).unwrap();
let preview = action(
pool.clone(),
config.clone(),
99,
false,
request(json!({"action":"detail","id":podcast})),
)
.await
.unwrap();
assert_eq!(preview["subscribed"], false);
let count: i64 =
sqlx::query_scalar("SELECT count(*) FROM furumusic__podcast_subscription WHERE user_id=99")
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(count, 0);
action(
pool.clone(),
config.clone(),
1,
false,
request(json!({"action":"remove","id":podcast})),
)
.await
.unwrap();
assert!(
action(
pool.clone(),
config.clone(),
99,
false,
request(json!({"action":"detail","id":podcast}))
)
.await
.is_err(),
"private podcasts must not be exposed by the detail route"
);
assert_eq!(
list(&pool, 2, false).await.unwrap()["mine"]
.as_array()
.unwrap()
.len(),
1
);
assert!(tokio::fs::try_exists(&media).await.unwrap());
let first = action(
pool.clone(),
config.clone(),
2,
false,
request(
json!({"action":"progress","id":episode.episode_id,"explicit":true,"position_ms":5000}),
),
)
.await
.unwrap();
let second = action(
pool.clone(),
config.clone(),
2,
false,
request(
json!({"action":"progress","id":episode.episode_id,"explicit":true,"position_ms":0}),
),
)
.await
.unwrap();
assert_eq!(
second["generation"].as_i64().unwrap(),
first["generation"].as_i64().unwrap() + 1
);
action(pool.clone(),config.clone(),2,false,request(json!({"action":"progress","id":episode.episode_id,"generation":first["generation"],"sequence":999,"position_ms":99999}))).await.unwrap();
let position: i64 = sqlx::query_scalar("SELECT position_ms FROM furumusic__podcast_progress")
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(position, 0);
assert!(
action(
pool.clone(),
config.clone(),
2,
false,
request(json!({"action":"admin_settings","retention_days":7}))
)
.await
.is_err()
);
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=now()-interval '20 days'")
.execute(&pool)
.await
.unwrap();
crate::podcasts::cleanup(&pool, &config).await.unwrap();
assert!(tokio::fs::try_exists(&media).await.unwrap());
action(
pool.clone(),
config.clone(),
1,
true,
request(json!({"action":"admin_settings","retention_days":7})),
)
.await
.unwrap();
crate::podcasts::cleanup(&pool, &config).await.unwrap();
assert!(!tokio::fs::try_exists(&media).await.unwrap());
let state: (bool,i64)=sqlx::query_as("SELECT expired,(SELECT count(*) FROM furumusic__podcast_progress) FROM furumusic__podcast_episode").fetch_one(&pool).await.unwrap();
assert_eq!(state, (true, 1));
action(
pool.clone(),
config.clone(),
1,
true,
request(json!({"action":"admin_delete","id":podcast})),
)
.await
.unwrap();
assert!(
list(&pool, 2, false).await.unwrap()["mine"]
.as_array()
.unwrap()
.is_empty()
);
// An actual v4 wire operation, as emitted by the TUI, creates the web
// subscription without HTTP fetching or a second manual subscription.
let url = FeedUrl::parse("https://example.test/tui-feed").unwrap();
let id = PodcastId::from_feed_url(&url);
let incoming:music_dht::device_sync::SyncOpWire=serde_json::from_value(json!({"op_id":"tui_test:1","origin_device_id":"tui_test","seq":1,"hlc_ms":42,"payload":{"kind":"podcast_subscription_set","podcast_id":id,"subscribed":true,"podcast":{"feed_url":url,"title":"ТАЙНЫ Космоса","description":"История МУЗЫКИ и Ελληνικά"},"feed_aliases":[url],"generation":1}})).unwrap();
sync::apply_op(&pool, 1, &incoming).await.unwrap();
assert_eq!(
list(&pool, 1, false).await.unwrap()["mine"][0]["id"],
json!(id)
);
assert_eq!(
super::super::search(&pool, 1, "тайны музыка", 10)
.await
.unwrap()
.len(),
0
);
for query in [
"тайны космоса",
"ТАЙНЫ КОСМОСА",
"история музыки",
"ελληνικά",
"ΕΛΛΗΝΙΚΆ",
] {
assert_eq!(
super::super::search(&pool, 1, query, 10)
.await
.unwrap()
.len(),
1,
"{query}"
);
}
assert!(
super::super::search(&pool, 2, "тайны", 10)
.await
.unwrap()
.is_empty()
);
let mut before = music_dht::device_sync::SyncSnapshot::default();
sync::append_snapshot(&pool, 1, &mut before).await.unwrap();
assert!(!before.for_peer(3).has_podcast_state());
// Simulate the same person's next connected device using another local
// user id, since local database user ids are not part of the wire contract.
sync::apply_snapshot(&pool, 2, &before).await.unwrap();
assert_eq!(
list(&pool, 2, false).await.unwrap()["mine"][0]["id"],
json!(id)
);
sync::local_subscription(&pool, 1, id.as_str(), false)
.await
.unwrap();
let mut after = music_dht::device_sync::SyncSnapshot::default();
sync::append_snapshot(&pool, 1, &mut after).await.unwrap();
sync::apply_snapshot(&pool, 2, &after).await.unwrap();
sync::apply_snapshot(&pool, 2, &before).await.unwrap();
sync::apply_op(&pool, 1, &incoming).await.unwrap();
assert!(
list(&pool, 1, false).await.unwrap()["mine"]
.as_array()
.unwrap()
.is_empty()
);
assert!(
list(&pool, 2, false).await.unwrap()["mine"]
.as_array()
.unwrap()
.is_empty()
);
let wire:music_dht::device_sync::SyncOpWire=serde_json::from_value(sqlx::query_scalar::<_,Value>("SELECT jsonb_build_object('op_id',op_id,'origin_device_id',origin_device_id,'seq',seq,'hlc_ms',hlc_ms,'payload',payload_json) FROM furumusic__fed_sync_ops WHERE user_id=1 AND kind='podcast_subscription_set' ORDER BY seq DESC LIMIT 1").fetch_one(&pool).await.unwrap()).unwrap();
assert!(!wire.podcast_subscription().unwrap().subscribed);
assert!(!music_dht::device_sync::op_allowed_for_peer(
&wire.payload,
3
));
assert!(music_dht::device_sync::op_allowed_for_peer(
&wire.payload,
4
));
pool.close().await;
sqlx::query(&format!("DROP SCHEMA {schema} CASCADE"))
.execute(&admin_pool)
.await
.unwrap();
tokio::fs::remove_dir_all(&directory).await.unwrap();
}
+475
View File
@@ -0,0 +1,475 @@
use super::*;
use crate::{auth, auth::Role};
use cot::http::{Request, StatusCode};
use cot::{
App, Body,
db::Database,
json::Json,
request::extractors::Path,
response::IntoResponse,
router::{
Route, Router,
method::{get, post},
},
session::Session,
};
use futures_util::TryStreamExt;
use serde::Deserialize;
use std::sync::Arc;
#[cfg(test)]
#[path = "tests.rs"]
mod tests;
#[derive(Deserialize)]
struct Action {
action: String,
#[serde(default)]
id: String,
#[serde(default)]
url: String,
#[serde(default)]
query: String,
#[serde(default)]
shared: bool,
#[serde(default)]
confirmed: bool,
#[serde(default)]
position_ms: i64,
#[serde(default)]
completed: bool,
#[serde(default)]
explicit: bool,
#[serde(default)]
generation: i64,
#[serde(default)]
sequence: i64,
#[serde(default)]
offset: i64,
retention_days: Option<i32>,
}
#[derive(Deserialize)]
struct EpisodePath {
id: String,
}
fn episode_path_id(value: &str) -> Result<music_dht::podcast::EpisodeId> {
// Cot's path extractor preserves percent escapes. The contract's only
// escaped path character is the colon separating the id prefix.
let decoded = value.replace("%3A", ":").replace("%3a", ":");
Ok(serde_json::from_value(json!(decoded))?)
}
fn error(status: StatusCode, message: &str) -> cot::Result<cot::response::Response> {
Ok(cot::http::Response::builder()
.status(status)
.header("Content-Type", "application/json")
.body(Body::fixed(json!({"error":message}).to_string()))
.expect("valid response"))
}
async fn list(pool: &PgPool, user: i64, admin: bool) -> Result<Value> {
let mine: Vec<Value> = sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'metadata',p.metadata,'shared',s.shared,'checked_at',p.checked_at,'error',p.last_error,'episodes',(SELECT count(*) FROM furumusic__podcast_episode e WHERE e.podcast_id=p.id),'new_episodes',(SELECT count(*) FROM furumusic__podcast_episode e WHERE e.podcast_id=p.id AND NOT EXISTS(SELECT 1 FROM furumusic__podcast_progress g WHERE g.user_id=$1 AND g.episode_id=e.id AND g.completed))) FROM furumusic__podcast p JOIN furumusic__podcast_subscription s ON s.podcast_id=p.id WHERE s.user_id=$1 ORDER BY p.metadata->>'title'").bind(user).fetch_all(pool).await?;
let public: Vec<Value> = sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'url',p.origin_url,'metadata',p.metadata,'subscribed',EXISTS(SELECT 1 FROM furumusic__podcast_subscription m WHERE m.user_id=$1 AND m.podcast_id=p.id)) FROM furumusic__podcast p WHERE EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id AND s.shared AND s.user_id<>$1) ORDER BY p.metadata->>'title' LIMIT 200").bind(user).fetch_all(pool).await?;
let mut result = json!({"mine":mine,"public":public});
if admin {
let all: Vec<Value> = sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'metadata',p.metadata,'error',p.last_error,'checked_at',p.checked_at,'subscribers',(SELECT count(*) FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id),'public',(SELECT count(*) FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id AND s.shared),'cached',(SELECT count(*) FROM furumusic__podcast_episode e WHERE e.podcast_id=p.id AND cached_at IS NOT NULL)) FROM furumusic__podcast p ORDER BY p.metadata->>'title'").fetch_all(pool).await?;
let days: Option<i32> =
sqlx::query_scalar("SELECT retention_days FROM furumusic__podcast_settings WHERE id=1")
.fetch_one(pool)
.await?;
result["all"] = json!(all);
result["retention_days"] = json!(days);
}
Ok(result)
}
async fn require_subscription(pool: &PgPool, user: i64, id: &str) -> Result<()> {
let yes: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__podcast_subscription WHERE user_id=$1 AND podcast_id=$2)").bind(user).bind(id).fetch_one(pool).await?;
if !yes {
bail!("podcast subscription not found");
}
Ok(())
}
async fn action(
pool: PgPool,
config: AppConfig,
user: i64,
admin: bool,
body: Action,
) -> Result<Value> {
if body.action.starts_with("admin_") && !admin {
bail!("administrator access required");
}
match body.action.as_str() {
"list" => return list(&pool, user, false).await,
"detail" => {
let detail:Option<Value>=sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'url',p.origin_url,'metadata',p.metadata,'subscribed',EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.user_id=$1 AND s.podcast_id=p.id),'episodes',(SELECT count(*) FROM furumusic__podcast_episode e WHERE e.podcast_id=p.id)) FROM furumusic__podcast p WHERE p.id=$2 AND EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id AND (s.user_id=$1 OR s.shared))").bind(user).bind(&body.id).fetch_optional(&pool).await?;
return detail.context("podcast not found");
}
"admin_list" => return list(&pool, user, true).await,
"add" => {
let id = subscribe(&pool, user, &body.url).await?;
sync::ensure_subscribed(&pool, user, &id).await?;
sync::seed_user(&pool, user).await?;
let checked = refresh(&pool, &id).await;
let download_id = id.clone();
tokio::spawn(async move {
let _ = download_pending(&pool, &config, Some(&download_id)).await;
});
return Ok(
json!({"ok":true,"id":id,"warning":checked.err().map(|_| "Feed check failed; the subscription was saved") }),
);
}
"remove" => {
require_subscription(&pool, user, &body.id).await?;
sync::local_subscription(&pool, user, &body.id, false).await?;
sqlx::query(
"DELETE FROM furumusic__podcast_subscription WHERE user_id=$1 AND podcast_id=$2",
)
.bind(user)
.bind(&body.id)
.execute(&pool)
.await?;
}
"share" => {
require_subscription(&pool, user, &body.id).await?;
sync::seed_user(&pool, user).await?;
let row = sqlx::query("SELECT origin_url,metadata FROM furumusic__podcast WHERE id=$1")
.bind(&body.id)
.fetch_one(&pool)
.await?;
let meta: PodcastMeta = serde_json::from_value(row.get("metadata"))?;
let origin = FeedUrl::parse(row.get::<&str, _>("origin_url"))?;
let sub = SubscriptionRecord {
podcast_id: serde_json::from_value(json!(body.id))?,
subscribed: true,
podcast: meta,
feed_aliases: vec![origin],
generation: 1,
hlc_ms: 1,
op_id: "web".into(),
};
let card = PodcastCardSpec::from_subscription(&sub)?;
let urls = json!([card.feed_url, card.id_feed_url]);
if body.shared && !body.confirmed && !card.privacy_warnings().is_empty() {
return Ok(json!({"confirmation_required":true,"urls":urls}));
}
sqlx::query("UPDATE furumusic__podcast_subscription SET shared=$3,confirmed_urls=$4 WHERE user_id=$1 AND podcast_id=$2").bind(user).bind(&body.id).bind(body.shared).bind(if body.shared {Some(urls)} else {None}).execute(&pool).await?;
sync::local_share(&pool, user, &body.id, body.shared).await?;
}
"episodes" => {
require_subscription(&pool, user, &body.id).await?;
let mut episodes: Vec<Value> = sqlx::query_scalar("SELECT jsonb_build_object('id',e.id,'metadata',e.metadata,'cached',e.cached_at IS NOT NULL,'downloading',COALESCE(e.download_until>now(),false),'error',e.download_error,'position_ms',COALESCE(g.position_ms,0),'completed',COALESCE(g.completed,false)) FROM furumusic__podcast_episode e LEFT JOIN furumusic__podcast_progress g ON g.episode_id=e.id AND g.user_id=$1 WHERE e.podcast_id=$2 ORDER BY (e.metadata->>'published_at_ms')::bigint DESC NULLS LAST,e.discovered_at DESC,e.id LIMIT 201 OFFSET $3").bind(user).bind(&body.id).bind(body.offset.max(0)).fetch_all(&pool).await?;
let more = episodes.len() > 200;
episodes.truncate(200);
return Ok(json!({"episodes":episodes,"has_more":more}));
}
"refresh" | "admin_refresh" => {
if body.action == "refresh" {
require_subscription(&pool, user, &body.id).await?;
}
let added = refresh(&pool, &body.id).await?;
tokio::spawn(async move {
let _ = download_pending(&pool, &config, Some(&body.id)).await;
});
return Ok(json!({"added":added}));
}
"download" | "progress" => {
let podcast: String =
sqlx::query_scalar("SELECT podcast_id FROM furumusic__podcast_episode WHERE id=$1")
.bind(&body.id)
.fetch_one(&pool)
.await?;
require_subscription(&pool, user, &podcast).await?;
if body.action == "download" {
tokio::spawn(async move {
let _ = download(&pool, &config, &body.id, true).await;
});
return Ok(json!({"ok":true}));
}
let duration: Option<i64> = sqlx::query_scalar("SELECT (metadata->>'duration_ms')::bigint FROM furumusic__podcast_episode WHERE id=$1").bind(&body.id).fetch_one(&pool).await?;
let completed = body.completed
|| (!body.explicit
&& music_dht::podcast::reaches_completion(body.position_ms, duration));
let generation: Option<i64> = if body.explicit {
Some(sqlx::query_scalar("INSERT INTO furumusic__podcast_progress(user_id,episode_id,position_ms,completed,generation,checkpoint) VALUES($1,$2,$3,$4,1,$5) ON CONFLICT(user_id,episode_id) DO UPDATE SET position_ms=EXCLUDED.position_ms,completed=EXCLUDED.completed,generation=furumusic__podcast_progress.generation+1,checkpoint=EXCLUDED.checkpoint,updated_at=now() RETURNING generation").bind(user).bind(&body.id).bind(body.position_ms.max(0)).bind(completed).bind(body.sequence).fetch_one(&pool).await?)
} else {
sqlx::query_scalar("UPDATE furumusic__podcast_progress SET position_ms=$3,completed=$4,checkpoint=$6,updated_at=now() WHERE user_id=$1 AND episode_id=$2 AND generation=$5 AND checkpoint<=$6 RETURNING generation").bind(user).bind(&body.id).bind(body.position_ms.max(0)).bind(completed).bind(body.generation).bind(body.sequence).fetch_optional(&pool).await?
};
if let Some(generation) = generation {
sync::local_progress(
&pool,
user,
&body.id,
generation.max(0) as u64,
body.position_ms.max(0),
completed,
)
.await?;
}
return Ok(json!({"ok":true,"generation":generation}));
}
"search" => {
if body.query.chars().count() < 2 || body.query.len() > 200 {
bail!("enter 2–200 characters");
}
let mut hits = super::search(&pool, user, &body.query, 100).await?;
if let Ok(Ok(Value::Array(remote))) = tokio::time::timeout(
Duration::from_secs(10),
crate::federation::handle().search_podcasts(&body.query),
)
.await
{
for hit in remote {
if !hits.iter().any(|local| local["id"] == hit["id"]) {
hits.push(hit);
}
}
}
return Ok(json!({"hits":hits}));
}
"admin_settings" => {
if body
.retention_days
.is_some_and(|days| !(1..=36500).contains(&days))
{
bail!("retention must be between 1 and 36500 days");
}
sqlx::query("UPDATE furumusic__podcast_settings SET retention_days=$1 WHERE id=1")
.bind(body.retention_days)
.execute(&pool)
.await?;
}
"admin_unpublish" => {
let owners:Vec<i64>=sqlx::query_scalar("SELECT user_id FROM furumusic__podcast_subscription WHERE podcast_id=$1 AND shared").bind(&body.id).fetch_all(&pool).await?;
for owner in owners {
sync::seed_user(&pool, owner).await?;
sync::local_share(&pool, owner, &body.id, false).await?;
}
sqlx::query("UPDATE furumusic__podcast_subscription SET shared=false,confirmed_urls=NULL WHERE podcast_id=$1").bind(&body.id).execute(&pool).await?;
}
"admin_clear" | "admin_delete" => {
if body.action == "admin_delete" {
let owners: Vec<i64> = sqlx::query_scalar(
"SELECT user_id FROM furumusic__podcast_subscription WHERE podcast_id=$1",
)
.bind(&body.id)
.fetch_all(&pool)
.await?;
for owner in owners {
sync::local_subscription(&pool, owner, &body.id, false).await?;
}
}
let mut tx = pool.begin().await?;
let locked: bool =
sqlx::query_scalar("SELECT pg_try_advisory_xact_lock(hashtextextended($1,7421))")
.bind(&body.id)
.fetch_one(&mut *tx)
.await?;
if !locked {
bail!("downloads are running; try again when they finish");
}
sqlx::query("SELECT id FROM furumusic__podcast WHERE id=$1 FOR UPDATE")
.bind(&body.id)
.fetch_optional(&mut *tx)
.await?;
let ids: Vec<String> =
sqlx::query_scalar("SELECT id FROM furumusic__podcast_episode WHERE podcast_id=$1")
.bind(&body.id)
.fetch_all(&pool)
.await?;
// A leased download must finish before clearing or deleting its catalogue.
let busy: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__podcast_episode WHERE podcast_id=$1 AND download_until>now())").bind(&body.id).fetch_one(&pool).await?;
if busy {
bail!("downloads are running; try again when they finish");
}
for id in ids {
match tokio::fs::remove_file(cache_path(&config, &id)).await {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) => return Err(e.into()),
}
}
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=NULL,expired=true WHERE podcast_id=$1").bind(&body.id).execute(&mut *tx).await?;
if body.action == "admin_delete" {
sqlx::query("DELETE FROM furumusic__podcast WHERE id=$1")
.bind(&body.id)
.execute(&mut *tx)
.await?;
}
tx.commit().await?;
}
_ => bail!("unknown podcast action"),
}
let federation = crate::federation::handle();
let pending = federation.sync_podcasts().await.is_err();
Ok(json!({"ok":true,"publication_pending":pending}))
}
async fn media(
pool: &PgPool,
config: &AppConfig,
user: i64,
id: &str,
request: &Request<Body>,
) -> Result<cot::response::Response> {
let row = sqlx::query("SELECT e.metadata,e.cached_at IS NOT NULL AS cached FROM furumusic__podcast_episode e JOIN furumusic__podcast_subscription s ON s.podcast_id=e.podcast_id WHERE e.id=$1 AND s.user_id=$2").bind(id).bind(user).fetch_one(pool).await?;
let meta: EpisodeMeta = serde_json::from_value(row.get("metadata"))?;
let range = request.headers().get("range").and_then(|v| v.to_str().ok());
let mut builder = cot::http::Response::builder().header("Cache-Control", "private, no-store");
let path = cache_path(config, id);
if row.get::<bool, _>("cached") && tokio::fs::try_exists(&path).await? {
use tokio::io::{AsyncReadExt, AsyncSeekExt};
let mut file = tokio::fs::File::open(&path).await?;
let size = file.metadata().await?.len();
let (start, end) = if let Some(range) = range {
match crate::player::parse_range(range, size) {
Some((start, end)) => {
builder = builder
.status(206)
.header("Content-Range", format!("bytes {start}-{end}/{size}"));
(start, end)
}
None => {
return Ok(builder
.status(416)
.header("Content-Range", format!("bytes */{size}"))
.body(Body::empty())?);
}
}
} else {
(0, size.saturating_sub(1))
};
file.seek(std::io::SeekFrom::Start(start)).await?;
let stream = tokio_util::io::ReaderStream::new(file.take(end - start + 1))
.map_err(|e| cot::Error::internal(e.to_string()));
return Ok(builder
.header("Content-Type", meta.mime.as_deref().unwrap_or("audio/mpeg"))
.header("Accept-Ranges", "bytes")
.header("Content-Length", (end - start + 1).to_string())
.body(Body::streaming(stream))?);
}
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=NULL WHERE id=$1")
.bind(id)
.execute(pool)
.await?;
let pool_clone = pool.clone();
let config_clone = config.clone();
let id_clone = id.to_owned();
tokio::spawn(async move {
let _ = download(&pool_clone, &config_clone, &id_clone, true).await;
});
let response = fetch(&meta.audio_url, range, None).await?;
builder = builder.status(response.status());
for key in [
"content-type",
"content-length",
"content-range",
"accept-ranges",
] {
if let Some(value) = response.headers().get(key) {
builder = builder.header(key, value);
}
}
let stream = response
.bytes_stream()
.map_err(|_| cot::Error::internal("podcast stream interrupted"));
Ok(builder.body(Body::streaming(stream))?)
}
pub struct PodcastApp {
config: Arc<AppConfig>,
}
impl PodcastApp {
pub fn new(config: Arc<AppConfig>) -> Self {
Self { config }
}
}
impl App for PodcastApp {
fn name(&self) -> &'static str {
"podcasts"
}
fn router(&self) -> Router {
let pool = sqlx::postgres::PgPoolOptions::new()
.max_connections(8)
.connect_lazy(&self.config.database_url)
.expect("podcast pool configuration");
let action_pool = pool.clone();
Router::with_urls([
Route::with_handler_and_name(
"/action",
{
post(
move |auth_ctx: auth::AuthContext,
session: Session,
db: Database,
Json(body): Json<Action>| {
let pool = action_pool.clone();
async move {
let Some(user) =
auth::get_request_user(&auth_ctx, &session, &db).await
else {
return error(StatusCode::UNAUTHORIZED, "not authenticated");
};
if body.action.starts_with("admin_") && user.role != Role::Admin {
return error(
StatusCode::FORBIDDEN,
"administrator access required",
);
}
let (config, _) = AppConfig::load_with_db(&db).await;
match action(pool, config, user.id, user.role == Role::Admin, body)
.await
{
Ok(value) => Json(value).into_response(),
Err(err) => {
let message = if err.downcast_ref::<sqlx::Error>().is_some()
{
"Podcast storage operation failed; try again".to_owned()
} else {
err.to_string()
};
error(StatusCode::BAD_REQUEST, &message)
}
}
}
},
)
},
"podcast_action",
),
Route::with_handler_and_name(
"/media/{id}",
{
get(
move |auth_ctx: auth::AuthContext,
session: Session,
db: Database,
path: Path<EpisodePath>,
request: Request<Body>| {
let pool = pool.clone();
async move {
let Some(user) =
auth::get_request_user(&auth_ctx, &session, &db).await
else {
return error(StatusCode::UNAUTHORIZED, "not authenticated");
};
let (config, _) = AppConfig::load_with_db(&db).await;
let Ok(id) = episode_path_id(&path.0.id) else {
return error(StatusCode::NOT_FOUND, "episode unavailable");
};
match media(&pool, &config, user.id, id.as_str(), &request).await {
Ok(response) => Ok(response),
Err(_) => error(StatusCode::NOT_FOUND, "episode unavailable"),
}
}
},
)
},
"podcast_media",
),
])
}
}
+193
View File
@@ -0,0 +1,193 @@
<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>
+2 -1
View File
@@ -631,9 +631,10 @@
<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="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="podcasts">Podcasts</option><option value="federation">Federation</option><option value="lastfm">Last.fm</option><option value="developer">Developer</option>
</select>
</label>
{% include "admin/podcasts.html" %}
<form class="settings-layout" @submit.prevent="saveSettings()">
<div class="settings-column">
<section class="panel settings-section settings-section-wide settings-oidc" id="settings-oidc">
+2
View File
@@ -4,10 +4,12 @@
{% block head_extra %}
{% include "player/styles.html" %}
{% include "player/podcast_styles.html" %}
{% endblock head_extra %}
{% block body %}
{% include "player/shell.html" %}
{% include "player/modals.html" %}
{% include "player/podcast_scripts.html" %}
{% include "player/scripts.html" %}
{% endblock body %}
+23
View File
@@ -0,0 +1,23 @@
<template x-if="$store.podcasts.artwork(pod)">
<img
:src="$store.podcasts.artwork(pod)"
alt=""
aria-hidden="true"
loading="lazy"
decoding="async"
referrerpolicy="no-referrer"
@error="$store.podcasts.artworkFailed(pod)"
/>
</template>
<template x-if="!$store.podcasts.artwork(pod)">
<svg
viewBox="0 0 24 24"
fill="none"
stroke="currentColor"
stroke-width="1.5"
aria-hidden="true"
>
<rect x="9" y="2" width="6" height="13" rx="3" />
<path d="M5 10v2a7 7 0 0014 0v-2M12 19v3M8 22h8" />
</svg>
</template>
+18
View File
@@ -0,0 +1,18 @@
<button
type="button"
class="card podcast-tile"
@click="$store.podcasts.open(pod)"
:title="pod.metadata.title"
>
<div class="card-img podcast-artwork">{% include "player/podcast_artwork.html" %}</div>
<div class="card-title" x-text="pod.metadata.title"></div>
<div
class="card-subtitle"
x-text="pod.metadata.author || $store.podcasts.text('podcasts')"
></div>
<div
class="card-subtitle"
x-show="pod.episodes != null"
x-text="(pod.episodes || 0) + ' ' + $store.podcasts.text('episodes') + (pod.new_episodes ? ' · ' + pod.new_episodes + ' ' + $store.podcasts.text('unplayed') : '')"
></div>
</button>
+61
View File
@@ -0,0 +1,61 @@
<h2 class="podcast-section-title" x-text="$store.podcasts.text('episodes')"></h2>
<div class="podcast-toolbar">
<input
type="text"
x-model="$store.podcasts.filter"
:placeholder="$store.podcasts.text('filter')"
:aria-label="$store.podcasts.text('filter')"
/><select x-model="$store.podcasts.season" :aria-label="$store.podcasts.text('season')">
<option value="" x-text="$store.podcasts.text('allSeasons')"></option>
<template x-for="season in $store.podcasts.seasons()" :key="season"
><option :value="season" x-text="$store.podcasts.text('season')+' '+season"></option
></template></select
><label
><input type="checkbox" x-model="$store.podcasts.unplayedOnly" />
<span x-text="$store.podcasts.text('unplayedOnly')"></span
></label>
</div>
<p
x-show="!$store.podcasts.filteredEpisodes().length"
x-text="$store.podcasts.text('noEpisodes')"
></p>
<template x-for="episode in $store.podcasts.filteredEpisodes()" :key="episode.id"
><article class="podcast-episode">
<h3 x-text="episode.metadata.title"></h3>
<div x-text="$store.podcasts.date(episode.metadata.published_at_ms)"></div>
<details x-show="episode.metadata.description">
<summary x-text="$store.podcasts.text('description')"></summary>
<p class="podcast-description" x-text="episode.metadata.description"></p>
</details>
<div class="podcast-toolbar">
<button
class="release-action-btn secondary"
@click="$store.podcasts.play(episode)"
x-text="$store.podcasts.text(episode.position_ms&&!episode.completed?'resume':'play')"
></button
><button
class="release-action-btn secondary"
@click="$store.podcasts.download(episode)"
:disabled="episode.cached||episode.downloading"
x-text="$store.podcasts.text(episode.cached?'saved':episode.downloading?'downloading':'download')"
></button
><button
class="release-action-btn secondary"
@click="$store.podcasts.mark(episode)"
x-text="$store.podcasts.text(episode.completed?'markUnplayed':'markPlayed')"
></button
><button
class="release-action-btn secondary"
x-show="episode.position_ms"
@click="$store.podcasts.restart(episode)"
x-text="$store.podcasts.text('restart')"
></button>
</div>
<div role="status" x-show="episode.error" x-text="episode.error"></div></article></template
><button
class="release-action-btn secondary"
x-show="$store.podcasts.hasMore"
@click="$store.podcasts.more()"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text('loadMore')"
></button>
+490
View File
@@ -0,0 +1,490 @@
<script>
document.addEventListener('alpine:init', () => {
const labels = {
podcasts: ['Podcasts', 'Подкасты'],
episodes: ['Episodes', 'Выпуски'],
subscribeHint: [
'Subscribe to listen and save episodes.',
'Подпишитесь, чтобы слушать и сохранять выпуски.',
],
notFound: ['Podcast not found.', 'Подкаст не найден.'],
showMore: ['Show more', 'Подробнее'],
showLess: ['Show less', 'Свернуть'],
add: ['Add', 'Добавить'],
mine: ['My podcasts', 'Мои подкасты'],
public: ['Public podcasts', 'Публичные подкасты'],
results: ['Podcast search results', 'Результаты поиска подкастов'],
noMatches: ['No matching podcasts.', 'Подходящих подкастов нет.'],
empty: ['Add an RSS or Atom feed.', 'Добавьте RSS или Atom ленту.'],
check: ['Check episodes', 'Проверить выпуски'],
checkAll: ['Check all', 'Проверить все'],
publish: ['Publish', 'Опубликовать'],
unpublish: ['Unpublish', 'Снять публикацию'],
remove: ['Unsubscribe', 'Отписаться'],
subscribe: ['Subscribe', 'Подписаться'],
play: ['Play', 'Слушать'],
open: ['Open', 'Открыть'],
resume: ['Resume', 'Продолжить'],
download: ['Save on server', 'Сохранить на сервере'],
saved: ['Saved on server', 'Сохранено на сервере'],
downloading: ['Downloading…', 'Скачивается…'],
markPlayed: ['Mark played', 'Прослушано'],
markUnplayed: ['Mark unplayed', 'Не прослушано'],
restart: ['Start over', 'С начала'],
filter: ['Filter episodes', 'Поиск выпусков'],
season: ['Season', 'Сезон'],
allSeasons: ['All seasons', 'Все сезоны'],
unplayed: ['unplayed', 'не прослушано'],
unplayedOnly: ['Unplayed only', 'Только непрослушанные'],
description: ['Description', 'Описание'],
noEpisodes: ['No episodes in this filter.', 'В этом фильтре нет выпусков.'],
noPublic: ['No public podcasts yet.', 'Публичных подкастов пока нет.'],
searchNetwork: ['Search podcasts', 'Поиск подкастов'],
search: ['Search', 'Найти'],
working: ['Working…', 'Выполняется…'],
done: ['Done', 'Готово'],
removeConfirm: [
'Remove only your subscription? Other subscribers keep access.',
'Удалить только вашу подписку? Доступ других подписчиков сохранится.',
],
shareConfirm: [
'Publish this feed URL to other users and Frid?',
'Опубликовать ссылку на ленту для других пользователей и Frid?',
],
privateConfirm: [
'This URL may contain private access credentials. Publish these exact URLs?',
'Ссылка может содержать приватный токен доступа. Опубликовать именно эти ссылки?',
],
pending: [
'Saved. Frid publication will retry when federation is available.',
'Сохранено. Публикация в Frid повторится, когда федерация будет доступна.',
],
checked: ['New episodes: ', 'Новых выпусков: '],
failed: [
'Operation failed. Please try again.',
'Не удалось выполнить действие. Повторите попытку.',
],
};
Alpine.store('podcasts', {
mine: [],
public: [],
hits: [],
searched: false,
episodes: [],
hasMore: false,
selected: null,
selectedId: null,
loading: false,
adding: false,
failedArtwork: {},
descriptionExpanded: false,
_navigation: 0,
url: '',
query: '',
filter: '',
season: '',
unplayedOnly: false,
busy: false,
message: '',
poller: null,
lastCheckpoint: 0,
text(key) {
if (key === 'loadMore')
return document.documentElement.lang.startsWith('ru')
? 'Загрузить ещё выпуски'
: 'Load more episodes';
return labels[key]?.[document.documentElement.lang.startsWith('ru') ? 1 : 0] || key;
},
async api(action, body = {}) {
const res = await fetch('/api/podcasts/action', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ action, ...body }),
});
const data = await res.json();
if (!res.ok) throw new Error(data.error || this.text('failed'));
return data;
},
async task(fn) {
if (this.busy) return;
this.busy = true;
this.message = this.text('working');
try {
await fn();
} catch (e) {
this.message = e.message || this.text('failed');
} finally {
this.busy = false;
}
},
async load() {
const data = await this.api('list');
this.mine = data.mine.map((pod) => ({ ...pod, subscribed: true }));
this.public = data.public;
if (this.selected) {
const current =
this.mine.find((p) => p.id === this.selected.id) ||
this.public.find((p) => p.id === this.selected.id);
this.selected = {
...this.selected,
...current,
subscribed: this.mine.some((p) => p.id === this.selected.id),
};
}
},
artwork(pod) {
const url = pod?.metadata?.image_url;
return url && !this.failedArtwork[url] ? url : null;
},
artworkFailed(pod) {
const url = pod?.metadata?.image_url;
if (url) this.failedArtwork[url] = true;
},
description(pod) {
const text = pod?.metadata?.description || '';
return !this.descriptionExpanded && text.length > 360
? text.slice(0, 360).trimEnd() + '…'
: text;
},
navigate(hash, view, options = {}) {
const library = Alpine.store('library');
library._beginNavigation(hash, options);
library.view = view;
library.currentArtist = null;
library.currentRelease = null;
library.currentPlaylist = null;
Alpine.store('mobile')?.closeLibrary();
this.ensurePolling();
},
ensurePolling() {
if (!this.poller)
this.poller = setInterval(() => {
if (
['podcasts', 'podcast_detail'].includes(Alpine.store('library').view) &&
!this.busy &&
!this.loading
)
this.update().catch(() => {});
}, 5000);
},
async enter(options = {}) {
const token = ++this._navigation;
this.navigate('#podcasts', 'podcasts', options);
this.selected = null;
this.selectedId = null;
this.episodes = [];
this.message = '';
this.loading = true;
try {
await this.load();
} catch (error) {
if (token === this._navigation) this.message = error.message;
} finally {
if (token === this._navigation) {
this.loading = false;
Alpine.store('library')._afterNavigation(options);
}
}
},
async update() {
await this.load();
if (this.selected?.subscribed) await this.loadEpisodes();
else this.episodes = [];
},
async loadEpisodes(append = false) {
const id = this.selected.id;
const offset = append ? this.episodes.length : 0;
const data = await this.api('episodes', { id, offset });
if (this.selected?.id !== id) return;
const old = this.episodes;
this.episodes = append
? [...old, ...data.episodes]
: [...new Map([...data.episodes, ...old].map((e) => [e.id, e])).values()];
if (append || old.length <= 200) this.hasMore = !!data.has_more;
},
more() {
return this.task(async () => {
await this.loadEpisodes(true);
this.message = '';
});
},
async open(pod, options = {}) {
const id = typeof pod === 'string' ? pod : pod.id;
const token = ++this._navigation;
this.selectedId = id;
this.descriptionExpanded = false;
const cached =
this.mine.find((p) => p.id === id) ||
this.public.find((p) => p.id === id) ||
(typeof pod === 'object' ? pod : null);
this.selected = cached
? {
...cached,
subscribed: this.mine.some((p) => p.id === id) || !!cached.subscribed,
}
: null;
this.episodes = [];
this.hasMore = false;
this.filter = '';
this.season = '';
this.message = '';
this.loading = true;
this.navigate('#podcast?id=' + encodeURIComponent(id), 'podcast_detail', options);
try {
await this.load();
if (token !== this._navigation) return;
const detail =
this.mine.find((p) => p.id === id) ||
this.public.find((p) => p.id === id) ||
this.selected ||
(await this.api('detail', { id }));
if (token !== this._navigation) return;
this.selected = { ...detail, subscribed: this.mine.some((p) => p.id === id) };
if (this.selected.subscribed) await this.loadEpisodes();
} catch (error) {
if (token === this._navigation)
this.message = error.message || this.text('notFound');
} finally {
if (token === this._navigation) {
this.loading = false;
Alpine.store('library')._afterNavigation(options);
}
}
},
openResult(pod) {
return this.open(pod);
},
subscribe(pod = this.selected) {
return this.task(async () => {
await this.api('add', { url: pod.url || pod.metadata.feed_url });
await this.load();
if (this.selectedId === pod.id) {
this.selected = this.mine.find((p) => p.id === pod.id) || {
...pod,
subscribed: true,
};
await this.loadEpisodes();
}
this.message = '';
});
},
add(url) {
this.task(async () => {
const result = await this.api('add', { url: url || this.url });
this.url = '';
await this.load();
this.adding = false;
if (result.id) await this.open(result.id);
this.message = result.warning || this.text('done');
});
},
remove(pod) {
if (!confirm(this.text('removeConfirm'))) return;
this.task(async () => {
const result = await this.api('remove', { id: pod.id });
if (this.selected?.id === pod.id) {
++this._navigation;
this.loading = false;
this.selected = null;
this.selectedId = null;
this.episodes = [];
this.navigate('#podcasts', 'podcasts');
Alpine.store('library')._afterNavigation();
}
await this.load();
this.message = this.text(result.publication_pending ? 'pending' : 'done');
});
},
share(pod) {
if (
!pod.shared &&
!confirm(this.text('shareConfirm') + '\n' + pod.metadata.feed_url)
)
return;
this.task(async () => {
let result = await this.api('share', { id: pod.id, shared: !pod.shared });
if (result.confirmation_required) {
if (
!confirm(
this.text('privateConfirm') +
'\n' +
result.urls.filter(Boolean).join('\n'),
)
) {
this.message = '';
return;
}
result = await this.api('share', {
id: pod.id,
shared: true,
confirmed: true,
});
}
await this.load();
this.message = this.text(result.publication_pending ? 'pending' : 'done');
});
},
refresh(pod) {
this.task(async () => {
const data = await this.api('refresh', { id: pod.id });
await this.update();
this.message = this.text('checked') + data.added;
});
},
refreshAll() {
this.task(async () => {
let count = 0;
for (const pod of this.mine) {
const data = await this.api('refresh', { id: pod.id });
count += data.added;
}
await this.update();
this.message = this.text('checked') + count;
});
},
download(episode) {
this.task(async () => {
await this.api('download', { id: episode.id });
episode.downloading = true;
this.message = this.text('downloading');
});
},
search() {
const query = this.query.trim();
return this.task(async () => {
const data = await this.api('search', { query });
if (this.query.trim() !== query) {
this.message = '';
return;
}
this.hits = data.hits;
this.searched = true;
this.message = this.text('done');
});
},
resetSearch() {
this.searched = false;
this.hits = [];
},
publicCards() {
return [
...new Map(
(this.searched ? this.hits : this.public).map((p) => [p.id, p]),
).values(),
];
},
seasons() {
return [
...new Set(
this.episodes.map((e) => e.metadata.season).filter((s) => s != null),
),
].sort((a, b) => a - b);
},
filteredEpisodes() {
const filter = this.filter.toLocaleLowerCase();
return this.episodes.filter(
(e) =>
(!filter || e.metadata.title.toLocaleLowerCase().includes(filter)) &&
(!this.season || String(e.metadata.season) === String(this.season)) &&
(!this.unplayedOnly || !e.completed),
);
},
date(ms) {
return ms ? new Date(ms).toLocaleDateString() : '';
},
play(episode) {
return this.task(async () => {
const devices = Alpine.store('devices');
if (devices && !devices.isActive()) await devices.select(devices.id);
const position = episode.completed ? 0 : episode.position_ms;
const session = await this.api('progress', {
id: episode.id,
position_ms: position,
explicit: true,
});
const player = Alpine.store('player');
player._playLocal(
{
id: episode.id,
podcast: true,
podcast_generation: session.generation,
podcast_id: episode.metadata.podcast_id,
title: episode.metadata.title,
artists: [{ id: null, name: this.selected.metadata.title }],
featured_artists: [],
release_id: null,
release_title: this.selected.metadata.title,
duration_seconds: (episode.metadata.duration_ms || 0) / 1000,
stream_url: '/api/podcasts/media/' + encodeURIComponent(episode.id),
cover_url:
episode.metadata.image_url || this.selected.metadata.image_url,
},
{ position_seconds: position / 1000 },
);
this.lastCheckpoint = Date.now();
this.message = '';
});
},
checkpoint(player, completed = false, unloading = false) {
const track = player.currentTrack;
if (!track?.podcast) return;
const payload = {
action: 'progress',
id: track.id,
position_ms: Math.round((player.currentTime || 0) * 1000),
completed,
generation: track.podcast_generation,
sequence: Date.now(),
};
const episode = this.episodes.find((e) => e.id === track.id);
if (episode) {
episode.position_ms = payload.position_ms;
episode.completed = completed;
}
if (unloading) {
navigator.sendBeacon(
'/api/podcasts/action',
new Blob([JSON.stringify(payload)], { type: 'application/json' }),
);
} else {
this.api('progress', payload).catch(() => {});
}
this.lastCheckpoint = Date.now();
},
tick(player) {
if (
player.currentTrack?.podcast &&
player.isPlaying &&
Date.now() - this.lastCheckpoint > 10000
)
this.checkpoint(player, !!player.currentTrack.podcast_completed);
},
mark(episode) {
return this.task(async () => {
const completed = !episode.completed;
const position = completed ? episode.position_ms : 0;
const result = await this.api('progress', {
id: episode.id,
position_ms: position,
completed,
explicit: true,
});
episode.completed = completed;
episode.position_ms = position;
const player = Alpine.store('player');
if (player.currentTrack?.id === episode.id) {
player.currentTrack.podcast_generation = result.generation;
player.currentTrack.podcast_completed = completed;
if (!completed) player.seek(0);
}
this.message = this.text('done');
});
},
restart(episode) {
episode.position_ms = 0;
episode.completed = false;
return this.play(episode);
},
});
});
</script>
+15
View File
@@ -0,0 +1,15 @@
<button
type="button"
class="search-release-card podcast-tile"
@click="$store.podcasts.open(pod)"
:title="pod.metadata.title"
>
<div class="search-release-cover podcast-artwork">
{% include "player/podcast_artwork.html" %}
</div>
<div class="card-title" x-text="pod.metadata.title"></div>
<div
class="card-subtitle"
x-text="pod.metadata.author || $store.podcasts.text('podcasts')"
></div>
</button>
+39
View File
@@ -0,0 +1,39 @@
<style>
.podcast-nav { appearance:none; border:0; background:transparent; width:100%; font:inherit; text-align:left; }
.podcast-heading { display:flex; align-items:center; justify-content:space-between; gap:16px; flex-wrap:wrap; margin-bottom:20px; }
.podcast-heading .section-title, .podcast-heading .release-actions { margin:0; }
.podcast-section { margin-top:32px; }
.podcast-section-title { font-size:20px; font-weight:700; margin:0 0 16px; }
.podcast-tile { appearance:none; border:0; color:var(--text-primary); font:inherit; text-align:left; min-width:0; }
.podcast-tile:focus-visible { outline:2px solid var(--accent); outline-offset:3px; }
.podcast-tile .card-subtitle { white-space:nowrap; overflow:hidden; text-overflow:ellipsis; }
.podcast-artwork { color:var(--text-subdued); }
.podcast-artwork svg { width:48px; height:48px; }
.podcast-tile img { display:block; }
.search-release-cover.podcast-artwork svg { width:40px; height:40px; }
.podcast-detail-actions { display:contents; }
.podcast-toolbar { display:flex; align-items:center; flex-wrap:wrap; gap:12px; margin:16px 0; }
.podcast-toolbar input[type=text], .podcast-toolbar select { background:var(--bg-secondary); color:var(--text-primary); border:1px solid var(--border-color); border-radius:6px; padding:10px 12px; font:inherit; min-width:0; }
.podcast-toolbar input[type=text] { flex:1; min-width:160px; }
.podcast-toolbar label { display:flex; align-items:center; gap:8px; font-size:13px; color:var(--text-secondary); }
.podcast-toolbar input[type=checkbox] { accent-color:var(--accent); }
.podcast-notice { margin:12px 0; font-size:13px; color:var(--text-secondary); overflow-wrap:anywhere; }
.podcast-detail .release-meta { min-width:0; flex:1; }
.podcast-detail .release-title { overflow-wrap:anywhere; }
.podcast-description { margin:0 0 28px; max-width:80ch; color:var(--text-secondary); font-size:14px; line-height:1.7; white-space:pre-line; overflow-wrap:anywhere; }
.podcast-description-section { margin-bottom:28px; }
.podcast-description-section .podcast-description { margin:0; }
.podcast-description-section .artist-top-tracks-toggle { margin-top:8px; padding-left:0; }
.podcast-episode { padding:16px 0; border-bottom:1px solid var(--border-color); }
.podcast-episode h3 { font-size:14px; font-weight:500; margin:0 0 6px; overflow-wrap:anywhere; }
.podcast-episode > div { font-size:12px; color:var(--text-subdued); }
.podcast-episode details { margin-top:8px; font-size:12px; color:var(--text-secondary); }
.podcast-episode summary { cursor:pointer; width:fit-content; }
.podcast-episode .podcast-description { margin:8px 0 0; }
.podcast-detail .release-action-btn:disabled, .podcast-toolbar button:disabled { opacity:.5; cursor:default; }
@media(max-width:600px) {
.podcast-heading { align-items:flex-start; gap:12px; }
.podcast-heading .release-actions { gap:8px; }
.podcast-toolbar input[type=text], .podcast-toolbar select { font-size:16px; min-height:44px; }
}
</style>
+211
View File
@@ -0,0 +1,211 @@
<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>
+22
View File
@@ -775,11 +775,18 @@ document.addEventListener('alpine:init', () => {
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()) {
@@ -796,6 +803,7 @@ 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;
@@ -884,6 +892,7 @@ document.addEventListener('alpine:init', () => {
},
_maybePrefetchNext() {
if (this.currentTrack?.podcast) return;
if (this.progress < 90 || !this.isPlaying) return;
const queue = Alpine.store('queue');
const nextIndex = queue?.currentIndex + 1;
@@ -900,6 +909,7 @@ document.addEventListener('alpine:init', () => {
},
_playLocal(track, options = {}) {
if (this.currentTrack?.podcast) Alpine.store('podcasts')?.checkpoint(this, !!this.currentTrack.podcast_completed);
this._recordHistory('replaced');
this.currentTrack = track;
this._historyTrack = track;
@@ -910,6 +920,9 @@ 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;
@@ -1208,6 +1221,7 @@ 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;
@@ -1406,6 +1420,7 @@ 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;
@@ -1418,6 +1433,7 @@ 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;
@@ -2653,6 +2669,12 @@ 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);
+14 -1
View File
@@ -75,6 +75,7 @@
<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">
@@ -187,6 +188,7 @@
<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">
@@ -407,6 +409,7 @@
</div>
<!-- Search Results -->
{% include "player/podcasts.html" %}
<template x-if="$store.library.view === 'search'">
<div>
<div class="search-similarity-heading"
@@ -437,7 +440,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">
<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">
<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>
@@ -548,6 +551,16 @@
</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">
+85
View File
@@ -0,0 +1,85 @@
// 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;});
+15
View File
@@ -0,0 +1,15 @@
CREATE TABLE furumusic__fed_device_identity (
user_id BIGINT PRIMARY KEY, device_id TEXT NOT NULL, group_id TEXT NOT NULL,
device_name TEXT NOT NULL, local_seq BIGINT DEFAULT 0, last_hlc_ms BIGINT DEFAULT 0,
local_seeded_at_ms BIGINT NOT NULL DEFAULT 1
);
CREATE TABLE furumusic__fed_sync_ops (
user_id BIGINT, op_id TEXT, origin_device_id TEXT, seq BIGINT, kind TEXT,
payload_json JSONB, hlc_ms BIGINT, received_at_ms BIGINT, tombstone BOOLEAN,
PRIMARY KEY(user_id,op_id)
);
CREATE TABLE furumusic__fed_sync_vector (
user_id BIGINT, device_id TEXT, max_seq BIGINT, PRIMARY KEY(user_id,device_id)
);
INSERT INTO furumusic__fed_device_identity(user_id,device_id,group_id,device_name)
VALUES(1,'web_test_one','group_test','one'),(2,'web_test_two','group_test','two');
+121
View File
@@ -0,0 +1,121 @@
const assert = require('node:assert/strict');
const {readFileSync} = require('node:fs');
const {test} = require('node:test');
const vm = require('node:vm');
const source = readFileSync(`${__dirname}/../templates/player/podcast_scripts.html`, 'utf8').replace(/<\/?script>/g, '');
function setup(responder=()=>({})) {
const calls=[],stores={library:{view:'artists',_beginNavigation(){},_afterNavigation(){}},mobile:{closeLibrary(){}},player:{_playLocal(track,options){this.currentTrack=track;this.options=options;},seek(){}}};
vm.runInNewContext(source,{
document:{documentElement:{lang:'ru'},addEventListener(_,fn){fn();}},
Alpine:{store(name,value){if(value)stores[name]=value;return stores[name];}},
fetch:async(url,options)=>{const body=JSON.parse(options.body);calls.push(body);return {ok:true,json:async()=>responder(body)};},
confirm:()=>true,setInterval:()=>1,Date,Map,Set,Blob,location:{hash:''},navigator:{sendBeacon(){}},
});
return {store:stores.podcasts,stores,calls};
}
const episode={id:'ep1:fixture',position_ms:123000,completed:false,metadata:{podcast_id:'pod1:fixture',title:'Episode',duration_ms:3600000,season:2}};
test('podcast playback resumes through the main player with episode identity and its own progress generation',async()=>{
const {store,stores,calls}=setup(()=>({generation:7}));
store.selected={metadata:{title:'Show'}};
await store.play({...episode});
assert.equal(stores.player.currentTrack.id,episode.id);
assert.equal(stores.player.currentTrack.podcast,true);
assert.equal(stores.player.currentTrack.podcast_generation,7);
assert.equal(stores.player.currentTrack.artists[0].name,'Show');
assert.equal(stores.player.options.position_seconds,123);
assert.equal(calls[0].explicit,true);
stores.player.currentTime=130;
store.checkpoint(stores.player);
assert.equal(calls[1].position_ms,130000);
assert.equal(calls[1].generation,7);
});
test('a completed episode starts at zero and restart resets a partial episode',async()=>{
const {store,stores}=setup(()=>({generation:2}));store.selected={metadata:{title:'Show'}};
await store.play({...episode,completed:true});assert.equal(stores.player.options.position_seconds,0);
const item={...episode};await store.restart(item);assert.equal(item.position_ms,0);assert.equal(stores.player.options.position_seconds,0);
});
test('marking unplayed is an explicit reset and advances the active session generation',async()=>{
const {store,stores,calls}=setup(()=>({generation:9}));
const item={...episode,completed:true};stores.player.currentTrack={id:item.id,podcast:true};
await store.mark(item);assert.equal(item.completed,false);assert.equal(item.position_ms,0);
assert.equal(calls[0].explicit,true);assert.equal(calls[0].position_ms,0);assert.equal(stores.player.currentTrack.podcast_generation,9);
});
test('filtering combines season, title and played status without mixing podcasts with music',()=>{
const {store}=setup();store.episodes=[{...episode},{...episode,id:'other',completed:true},{...episode,id:'season3',metadata:{...episode.metadata,season:3}}];
store.filter='epis';store.season='2';store.unplayedOnly=true;assert.deepEqual(Array.from(store.filteredEpisodes(),e=>e.id),[episode.id]);
store.public=[{id:'a',url:'origin'}];store.hits=[{id:'a',url:'origin'},{id:'b',url:'other'}];store.searched=true;assert.equal(store.publicCards().length,2);
});
test('private URL publication requires a separate confirmation; revocation does not republish',async()=>{
const {store,calls}=setup(body=>body.action==='share'&&!body.confirmed?{confirmation_required:true,urls:['https://example.test/feed?token=private']}:body.action==='list'?{mine:[],public:[]}:{ok:true});
await store.share({id:'a',shared:false,metadata:{feed_url:'https://example.test/feed?token=private'}});
// UI actions return task promises through the busy flag; flush the asynchronous load.
while(store.busy)await new Promise(resolve=>setImmediate(resolve));
const shares=calls.filter(c=>c.action==='share');assert.equal(shares.length,2);assert.equal(shares[1].confirmed,true);
});
test('admin and player inline scripts parse without a browser',()=>{
for(const file of ['templates/admin/podcasts.html','templates/player/podcast_scripts.html']) {
const html=readFileSync(`${__dirname}/../${file}`,'utf8');for(const match of html.matchAll(/<script>([\s\S]*?)<\/script>/g))new vm.Script(match[1]);
}
});
test('new episodes do not create gaps in previously loaded pages',async()=>{
let items=Array.from({length:202},(_,i)=>({id:'episode-'+i,metadata:{title:String(i)}}));
const {store}=setup(body=>({episodes:items.slice(body.offset,body.offset+200),has_more:body.offset+200<items.length}));
store.selected={id:'show'};
await store.loadEpisodes();await store.loadEpisodes(true);assert.equal(store.episodes.length,202);
items=[{id:'new',metadata:{title:'new'}},...items];
await store.loadEpisodes();assert.equal(store.episodes.length,203);
assert.equal(store.episodes[0].id,'new');assert.ok(store.episodes.some(e=>e.id==='episode-199'));
});
test('opening podcast navigation starts polling and search results open existing subscriptions',async()=>{
const podcast={id:'show',metadata:{title:'Show'},subscribed:true};
const {store,stores,calls}=setup(body=>body.action==='list'?{mine:[podcast],public:[]}:body.action==='episodes'?{episodes:[],has_more:false}:{});
await store.enter();assert.equal(store.poller,1);assert.equal(stores.library.view,'podcasts');
stores.library.view='search';await store.openResult(podcast);
assert.equal(stores.library.view,'podcast_detail');assert.equal(store.selected.id,'show');
assert.equal(calls.filter(c=>c.action==='add').length,0);
});
test('podcast search displays matching results instead of retaining unrelated public cards',async()=>{
const {store}=setup(()=>({hits:[{id:'matching',metadata:{title:'Found'}}]}));
store.public=[{id:'unrelated'}];store.query='космос';await store.search();
assert.deepEqual(Array.from(store.publicCards(),p=>p.id),['matching']);
store.resetSearch();assert.deepEqual(Array.from(store.publicCards(),p=>p.id),['unrelated']);
});
test('public podcast cards preview details without subscribing; only the subscribe button adds the feed',async()=>{
const pod={id:'public',url:'https://example.test/feed',metadata:{title:'Public',image_url:'https://example.test/cover.jpg'}};
let subscribed=false;
const {store,stores,calls}=setup(body=>{
if(body.action==='add'){subscribed=true;return {id:pod.id};}
if(body.action==='list')return {mine:subscribed?[pod]:[],public:[pod]};
return {episodes:[],has_more:false};
});
await store.open(pod);assert.equal(stores.library.view,'podcast_detail');
assert.equal(store.selected.subscribed,false);assert.equal(calls.filter(c=>c.action==='add').length,0);
assert.equal(calls.filter(c=>c.action==='episodes').length,0);
await store.subscribe();assert.equal(store.selected.subscribed,true);
assert.equal(calls.filter(c=>c.action==='add').length,1);assert.equal(calls.filter(c=>c.action==='episodes').length,1);
assert.equal(store.artwork(pod),pod.metadata.image_url);store.artworkFailed(pod);assert.equal(store.artwork(pod),null);
});
test('back navigation wins over a slow detail request',async()=>{
let finish;
const {store,stores}=setup(body=>body.action==='detail'?new Promise(resolve=>{finish=resolve;}):{mine:[],public:[]});
const opened=store.open('slow');while(!finish)await new Promise(resolve=>setImmediate(resolve));
await store.enter();finish({id:'slow',metadata:{title:'Old'}});await opened;
assert.equal(stores.library.view,'podcasts');assert.equal(store.selected,null);assert.equal(store.loading,false);
});
test('hash routing restores both the podcast list and a selected podcast',()=>{
const script=readFileSync(`${__dirname}/../templates/player/scripts.html`,'utf8');
const start=script.indexOf(' _navigateFromHash(options = {}) {');const end=script.indexOf(' _scrollElement()',start);
const calls=[],location={hash:'#podcasts'};
const context=vm.createContext({GUEST:false,location,URLSearchParams,Alpine:{store(){return {enter(options){calls.push(['list',options]);},open(id,options){calls.push(['detail',id,options]);}};}}});
const library=vm.runInContext('({'+script.slice(start,end)+'})',context);library.goArtists=()=>{throw Error('unexpected artist navigation');};
library._navigateFromHash({fromHash:true});assert.equal(calls[0][0],'list');assert.equal(calls[0][1].fromHash,true);
location.hash='#podcast?id='+encodeURIComponent('pod1:fixture');library._navigateFromHash({fromHash:true});
assert.equal(calls[1][0],'detail');assert.equal(calls[1][1],'pod1:fixture');
});
+14
View File
@@ -0,0 +1,14 @@
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);