diff --git a/Cargo.lock b/Cargo.lock index 68a93ca..a1bffda 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -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", @@ -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", ] diff --git a/Cargo.toml b/Cargo.toml index bbc8624..1573808 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -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"] } diff --git a/docs/administration.md b/docs/administration.md index 0b13bc8..bcad054 100644 --- a/docs/administration.md +++ b/docs/administration.md @@ -2,6 +2,38 @@ [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. Podcast personal state is not replicated to trusted Frid devices +yet; device synchronization continues to advertise protocol v3. + ## Access and public sharing OIDC identifies accounts by issuer and subject. Matching admin groups take diff --git a/docs/development.md b/docs/development.md index bad10bc..dce48b2 100644 --- a/docs/development.md +++ b/docs/development.md @@ -55,6 +55,18 @@ 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_TEST_DATABASE_URL=postgresql://... cargo test podcasts -- --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 access regression suite uses a disposable migrated database and a local OIDC provider with signed tokens and PKCE: diff --git a/src/federation/capabilities.rs b/src/federation/capabilities.rs index 26cf5c5..df35a2a 100644 --- a/src/federation/capabilities.rs +++ b/src/federation/capabilities.rs @@ -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) + // Podcast discovery is supported, but personal device sync remains v3. + .with_protocol(DEVICE_SYNC_ID, super::devices::PROTOCOL_VERSION) .with_protocol("audio", AUDIO_PROTOCOL_VERSION) .with_protocol( SIMILARITY_ID, diff --git a/src/federation/devices.rs b/src/federation/devices.rs index 125aa4f..c09081f 100644 --- a/src/federation/devices.rs +++ b/src/federation/devices.rs @@ -27,7 +27,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 = 3; 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); diff --git a/src/federation/mod.rs b/src/federation/mod.rs index 435b019..2ce9ddc 100644 --- a/src/federation/mod.rs +++ b/src/federation/mod.rs @@ -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, similarity_dht: Arc, + podcast_dht: Arc, network_name: String, tasks: Vec>, } @@ -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 { + 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}})).collect())) + } + async fn similarity_services(&self) -> Result<(Arc, Arc)> { self.running .lock() diff --git a/src/main.rs b/src/main.rs index d3a02c4..1bffe62 100644 --- a/src/main.rs +++ b/src/main.rs @@ -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 { 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), diff --git a/src/music/mod.rs b/src/music/mod.rs index 2ec4b03..3f778c4 100644 --- a/src/music/mod.rs +++ b/src/music/mod.rs @@ -2838,6 +2838,33 @@ 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()]; + } + pub const MIGRATIONS: &[&SyncDynMigration] = &[ &M0006CreateMediaFile, &M0007CreateArtist, @@ -2881,5 +2908,6 @@ pub mod db_migrations { &M0050CreateMetadataFixHistory, &M0051AddListenStatisticsIndexes, &M0052AddImportPlaylistDestinations, + &M0054CreatePodcasts, ]; } diff --git a/src/player/mod.rs b/src/player/mod.rs index ac6e0bd..2b0c478 100644 --- a/src/player/mod.rs +++ b/src/player/mod.rs @@ -5467,7 +5467,7 @@ fn hex_value(byte: u8) -> Option { } } -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; } diff --git a/src/podcasts/mod.rs b/src/podcasts/mod.rs new file mode 100644 index 0000000..9469c57 --- /dev/null +++ b/src/podcasts/mod.rs @@ -0,0 +1,486 @@ +//! Server-owned podcast catalogue and cache; subscriptions and progress are personal. +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; + +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 { + 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> { + 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 { + let origin = FeedUrl::from_user_input(input)?; + let existing: Option = + 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 = 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 { + 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 { + 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 = row.get("etag"); + let modified: Option = 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 = + 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::) + .collect::, _>>()? + .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); + } + 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 = + 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 = 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 = 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 = 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 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 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 { + 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 = 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 = + 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 = + 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$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$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())); + } +} diff --git a/src/podcasts/schema.sql b/src/podcasts/schema.sql new file mode 100644 index 0000000..16bc37c --- /dev/null +++ b/src/podcasts/schema.sql @@ -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; diff --git a/src/podcasts/tests.rs b/src/podcasts/tests.rs new file mode 100644 index 0000000..0783baf --- /dev/null +++ b/src/podcasts/tests.rs @@ -0,0 +1,282 @@ +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")); + 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(); + let origin = FeedUrl::parse("https://example.test/feed.xml").unwrap(); + let podcast = PodcastId::from_feed_url(&origin); + let feed=parse_feed_with_base(br#"FixtureEpisodeone"#,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::(value).unwrap(); + action( + pool.clone(), + config.clone(), + 1, + false, + request(json!({"action":"remove","id":podcast})), + ) + .await + .unwrap(); + 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() + ); + pool.close().await; + sqlx::query(&format!("DROP SCHEMA {schema} CASCADE")) + .execute(&admin_pool) + .await + .unwrap(); + tokio::fs::remove_dir_all(&directory).await.unwrap(); +} diff --git a/src/podcasts/web.rs b/src/podcasts/web.rs new file mode 100644 index 0000000..448f0a4 --- /dev/null +++ b/src/podcasts/web.rs @@ -0,0 +1,427 @@ +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, +} +#[derive(Deserialize)] +struct EpisodePath { + id: String, +} + +fn episode_path_id(value: &str) -> Result { + // 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 { + 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 { + let mine: Vec = 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 = 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 = 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 = + 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 { + if body.action.starts_with("admin_") && !admin { + bail!("administrator access required"); + } + match body.action.as_str() { + "list" => return list(&pool, user, false).await, + "admin_list" => return list(&pool, user, true).await, + "add" => { + let id = subscribe(&pool, user, &body.url).await?; + let checked = refresh(&pool, &id).await; + tokio::spawn(async move { + let _ = download_pending(&pool, &config, Some(&id)).await; + }); + return Ok( + json!({"ok":true,"warning":checked.err().map(|_| "Feed check failed; the subscription was saved") }), + ); + } + "remove" => { + 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?; + 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?; + } + "episodes" => { + require_subscription(&pool, user, &body.id).await?; + let mut episodes: Vec = 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 = 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 = 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? + }; + return Ok(json!({"ok":true,"generation":generation})); + } + "search" => { + if body.query.chars().count() < 2 || body.query.len() > 200 { + bail!("enter 2–200 characters"); + } + let hits = crate::federation::handle() + .search_podcasts(&body.query) + .await?; + 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" => { + 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" => { + 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 = + 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, +) -> Result { + 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::("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, +} +impl PodcastApp { + pub fn new(config: Arc) -> 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| { + 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::().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, + request: Request| { + 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", + ), + ]) + } +} diff --git a/templates/admin/podcasts.html b/templates/admin/podcasts.html new file mode 100644 index 0000000..ec85488 --- /dev/null +++ b/templates/admin/podcasts.html @@ -0,0 +1,193 @@ +
+
+
+ PodcastsShared catalogue, publications and audio retention +
+ +
+ +
+ diff --git a/templates/admin/v2.html b/templates/admin/v2.html index f98e866..ba9c176 100644 --- a/templates/admin/v2.html +++ b/templates/admin/v2.html @@ -631,9 +631,10 @@
+ {% include "admin/podcasts.html" %}
diff --git a/templates/player.html b/templates/player.html index ce3ff70..158f87b 100644 --- a/templates/player.html +++ b/templates/player.html @@ -10,4 +10,5 @@ {% include "player/shell.html" %} {% include "player/modals.html" %} {% include "player/scripts.html" %} +{% include "player/podcast_scripts.html" %} {% endblock body %} diff --git a/templates/player/podcast_scripts.html b/templates/player/podcast_scripts.html new file mode 100644 index 0000000..e4433ef --- /dev/null +++ b/templates/player/podcast_scripts.html @@ -0,0 +1,358 @@ + diff --git a/templates/player/podcasts.html b/templates/player/podcasts.html new file mode 100644 index 0000000..2befaba --- /dev/null +++ b/templates/player/podcasts.html @@ -0,0 +1,173 @@ + + diff --git a/templates/player/scripts.html b/templates/player/scripts.html index c754b49..cc7fa0a 100644 --- a/templates/player/scripts.html +++ b/templates/player/scripts.html @@ -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; diff --git a/templates/player/shell.html b/templates/player/shell.html index b762efe..d8fc1ec 100644 --- a/templates/player/shell.html +++ b/templates/player/shell.html @@ -75,6 +75,7 @@ {{ t.player_my_uploads }}
+
@@ -407,6 +409,7 @@
+ {% include "player/podcasts.html" %}