Compare commits

...
2 Commits
Author SHA1 Message Date
ab 441316f78f Fix lock
Build and Publish / Build and Publish Docker Image (push) Successful in 4m11s
2026-11-22 16:12:52 +02:00
ab be7ccd5b4f Added podcasts support
Build and Publish / Build and Publish Docker Image (push) Failing after 1m55s
2026-11-22 16:05:37 +02:00
22 changed files with 2241 additions and 46 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"] }
+32
View File
@@ -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
+12
View File
@@ -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:
+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)
// 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,
+1 -1
View File
@@ -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);
+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}})).collect()))
}
async fn similarity_services(&self) -> Result<(Arc<MusicDhtService>, Arc<SimilarityDht>)> {
self.running
.lock()
+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),
+28
View File
@@ -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,
];
}
+1 -1
View File
@@ -5467,7 +5467,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;
}
+486
View File
@@ -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<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);
}
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 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<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;
+282
View File
@@ -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#"<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();
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();
}
+427
View File
@@ -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<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,
"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<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?
};
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<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">
+1
View File
@@ -10,4 +10,5 @@
{% include "player/shell.html" %}
{% include "player/modals.html" %}
{% include "player/scripts.html" %}
{% include "player/podcast_scripts.html" %}
{% endblock body %}
+358
View File
@@ -0,0 +1,358 @@
<script>
document.addEventListener('alpine:init', () => {
const labels = {
podcasts: ['Podcasts', 'Подкасты'],
add: ['Add', 'Добавить'],
mine: ['My podcasts', 'Мои подкасты'],
public: ['Public 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', 'Слушать'],
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 Frid podcasts', 'Поиск подкастов в Frid'],
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: [],
episodes: [],
hasMore: false,
selected: null,
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;
this.public = data.public;
},
enter() {
Alpine.store('library').view = 'podcasts';
Alpine.store('mobile')?.closeLibrary();
this.task(async () => {
await this.load();
this.message = '';
});
if (!this.poller)
this.poller = setInterval(() => {
if (Alpine.store('library').view === 'podcasts' && !this.busy)
this.update().catch(() => {});
}, 5000);
},
async update() {
await this.load();
if (this.selected && !this.mine.some((p) => p.id === this.selected.id)) {
this.selected = null;
this.episodes = [];
}
if (this.selected) await this.loadEpisodes();
},
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 = '';
});
},
open(pod) {
this.selected = pod;
this.episodes = [];
this.hasMore = false;
this.filter = '';
this.season = '';
this.task(async () => {
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.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.selected = null;
this.episodes = [];
}
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() {
this.task(async () => {
const data = await this.api('search', { query: this.query });
this.hits = data.hits;
this.message = this.text('done');
});
},
publicCards() {
return [...new Map([...this.public, ...this.hits].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>
+173
View File
@@ -0,0 +1,173 @@
<style>
.podcast-nav{appearance:none;border:0;background:transparent;width:100%;font:inherit;text-align:left}
.podcast-page{padding:20px;max-width:1100px;margin:auto}.podcast-toolbar{display:flex;gap:10px;align-items:center;flex-wrap:wrap;margin:16px 0}.podcast-toolbar input,.podcast-toolbar select{background:var(--bg-secondary,#171c28);color:inherit;border:1px solid var(--border,#384052);border-radius:8px;padding:10px;max-width:100%}.podcast-toolbar input[type=text]{flex:1;min-width:160px}.podcast-page button{border:1px solid var(--border,#384052);background:var(--bg-secondary,#171c28);color:inherit;border-radius:8px;padding:8px 12px;cursor:pointer}.podcast-page button:disabled{opacity:.5}.podcast-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(280px,100%),1fr));gap:14px;margin:16px 0 28px}.podcast-card,.podcast-episode{border:1px solid var(--border,#384052);border-radius:12px;padding:16px;overflow-wrap:anywhere}.podcast-card h3,.podcast-episode h3{margin:0 0 8px}.podcast-description{color:var(--text-secondary,#a2a9b8);white-space:pre-line;margin:8px 0}.podcast-episode{margin:10px 0}.podcast-notice{padding:12px 0;color:var(--accent,#67e8f9)}@media(max-width:600px){.podcast-page{padding:12px}.podcast-page button,.podcast-page input,.podcast-page select{min-height:44px;font-size:16px}}
</style>
<template x-if="$store.library.view === 'podcasts'">
<section class="podcast-page">
<h1 x-text="$store.podcasts.text('podcasts')"></h1>
<form class="podcast-toolbar" @submit.prevent="$store.podcasts.add()">
<input
type="text"
x-model="$store.podcasts.url"
placeholder="RSS / Atom URL"
aria-label="RSS / Atom URL"
required
/><button :disabled="$store.podcasts.busy" x-text="$store.podcasts.text('add')"></button
><button
type="button"
@click="$store.podcasts.refreshAll()"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text('checkAll')"
></button>
</form>
<div
role="status"
aria-live="polite"
class="podcast-notice"
x-text="$store.podcasts.message"
></div>
<h2 x-text="$store.podcasts.text('mine')"></h2>
<p x-show="!$store.podcasts.mine.length" x-text="$store.podcasts.text('empty')"></p>
<div class="podcast-grid">
<template x-for="pod in $store.podcasts.mine" :key="pod.id"
><article class="podcast-card">
<h3>
<button
@click="$store.podcasts.open(pod)"
x-text="pod.metadata.title"
></button>
</h3>
<div x-text="pod.metadata.author"></div>
<div
class="podcast-description"
x-text="pod.episodes+' · '+pod.new_episodes+' '+$store.podcasts.text('unplayed')"
></div>
<div x-show="pod.error" x-text="pod.error"></div>
<div class="podcast-toolbar">
<button
@click="$store.podcasts.refresh(pod)"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text('check')"
></button
><button
@click="$store.podcasts.share(pod)"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text(pod.shared?'unpublish':'publish')"
></button
><button
@click="$store.podcasts.remove(pod)"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text('remove')"
></button>
</div></article
></template>
</div>
<template x-if="$store.podcasts.selected"
><section>
<h2 x-text="$store.podcasts.selected.metadata.title"></h2>
<p
class="podcast-description"
x-text="$store.podcasts.selected.metadata.description"
></p>
<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
@click="$store.podcasts.play(episode)"
x-text="$store.podcasts.text(episode.position_ms&&!episode.completed?'resume':'play')"
></button
><button
@click="$store.podcasts.download(episode)"
:disabled="episode.cached||episode.downloading"
x-text="$store.podcasts.text(episode.cached?'saved':episode.downloading?'downloading':'download')"
></button
><button
@click="$store.podcasts.mark(episode)"
x-text="$store.podcasts.text(episode.completed?'markUnplayed':'markPlayed')"
></button
><button
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
x-show="$store.podcasts.hasMore"
@click="$store.podcasts.more()"
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text('loadMore')"
></button></section
></template>
<h2 x-text="$store.podcasts.text('public')"></h2>
<form class="podcast-toolbar" @submit.prevent="$store.podcasts.search()">
<input
type="text"
x-model="$store.podcasts.query"
:placeholder="$store.podcasts.text('searchNetwork')"
:aria-label="$store.podcasts.text('searchNetwork')"
minlength="2"
maxlength="200"
/><button
:disabled="$store.podcasts.busy"
x-text="$store.podcasts.text('search')"
></button>
</form>
<p
x-show="!$store.podcasts.public.length&&!$store.podcasts.hits.length"
x-text="$store.podcasts.text('noPublic')"
></p>
<div class="podcast-grid">
<template x-for="pod in $store.podcasts.publicCards()" :key="pod.id"
><article class="podcast-card">
<h3 x-text="pod.metadata.title"></h3>
<div x-text="pod.metadata.author"></div>
<p class="podcast-description" x-text="pod.metadata.description"></p>
<button
@click="$store.podcasts.add(pod.url)"
:disabled="$store.podcasts.busy||$store.podcasts.mine.some(p=>p.id===pod.id)"
x-text="$store.podcasts.text('subscribe')"
></button></article
></template>
</div></section
></template>
+16
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;
+3
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:$store.library.view==='podcasts'}" @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:$store.library.view==='podcasts'}" @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"
+70
View File
@@ -0,0 +1,70 @@
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'},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,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'}];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'));
});