diff --git a/src/podcasts/mod.rs b/src/podcasts/mod.rs index aafa3f2..c880526 100644 --- a/src/podcasts/mod.rs +++ b/src/podcasts/mod.rs @@ -18,19 +18,24 @@ //! bounded HTTP Range reader, and [`playback`] resolves the current audio //! URL and resume position, opens and positions it; //! * [`progress`] writes resume positions, completions and listening -//! sessions in order on its own thread. +//! sessions in order on its own thread; +//! * [`publication`] publishes the podcasts the user chose to share to the +//! public discovery overlay (`music_dht::podcast_dht`) and revokes them. //! //! Only RSS metadata is stored. Audio stays on the publisher's server. pub mod fetch; pub mod playback; pub mod progress; +pub mod publication; pub mod refresh; pub mod stream; #[cfg(test)] mod playback_tests; #[cfg(test)] +mod publication_tests; +#[cfg(test)] mod stream_tests; #[cfg(test)] mod test_server; @@ -111,10 +116,13 @@ pub fn open_services(db_path: &Path, covers_dir: PathBuf, log: Arc) - Ok(_) => {} Err(err) => tracing::debug!("reading the podcast import quarantine failed: {err:#}"), } + let confirmations = + publication::ShareConfirmations::open(publication::confirmations_path(db_path)); Ok(Services { store: Arc::new(store), fetcher: Arc::new(Fetcher::new(covers_dir)?), log, + confirmations: Arc::new(confirmations), }) } diff --git a/src/podcasts/publication.rs b/src/podcasts/publication.rs new file mode 100644 index 0000000..e4aa9fc --- /dev/null +++ b/src/podcasts/publication.rs @@ -0,0 +1,567 @@ +//! Public podcast discovery: publishing the podcasts the user chose to share. +//! +//! The share decision itself is synced personal state +//! (`PodcastStore::set_shared`, operation `podcast_share_set`); this module +//! turns the merged registers into this device's own publications in the +//! FRID overlay `music_dht::podcast_dht`: +//! +//! * [`share_states`] builds one `PodcastShareState` per subscription, the +//! integration pattern FRID documents for SQLite clients: the merged +//! subscription and share registers, a card whose `feed_url` is the URL +//! this device fetches (catalog) and whose `id_feed_url` is the origin +//! URL, and the local privacy confirmation. A card is only built for a +//! podcast that is effectively shared; private subscriptions contribute +//! their registers only, and `PodcastDht::sync_shares` never publishes +//! them. +//! * [`reconcile`] hands those states to `PodcastDht::sync_shares`, which is +//! declarative and idempotent: it publishes what is shared and tombstones +//! every own publication that is not (share turned off or unsubscribed on +//! any trusted device). A stale device cannot republish, because its +//! registers lose to the newer share decision once they converge. +//! * [`spawn`] runs the reconciler off the UI thread: after local share and +//! unsubscribe actions, after received podcast operations, after feed +//! refreshes (card metadata), when the overlay (re)starts, and +//! periodically. +//! * [`ShareConfirmations`] remembers, on this device only, that the user +//! confirmed publishing feed URLs that look private +//! (`PodcastCardSpec::privacy_warnings`). FRID leaves this confirmation to +//! the client and does not sync it: every device asks its own user before +//! it publishes such a URL under its own identity. A confirmation is bound +//! to the exact URLs shown, so a feed that moves to another URL asks again. +//! +//! Logging stays free of private data: only counts are logged, never feed +//! URLs, titles or ids of podcasts that are not shared. + +use std::collections::{BTreeMap, BTreeSet}; +use std::path::{Path, PathBuf}; +use std::sync::{Arc, Mutex, PoisonError}; +use std::time::Duration; + +use anyhow::{Context, Result}; +use furumi_library::podcasts::{PodcastListFilter, PodcastStore, PodcastSummary}; +use music_dht::podcast::{FeedUrl, PodcastId, SubscriptionRecord, effective_share}; +use music_dht::podcast_dht::{ + FeedUrlPrivacyWarning, PodcastCardSpec, PodcastDht, PodcastShareState, +}; +use serde::{Deserialize, Serialize}; +use tokio::sync::{Notify, watch}; + +/// Local file with the privacy confirmations, next to `podcasts.sqlite3`. +pub const CONFIRMATIONS_FILE: &str = "podcast-share-confirmations.json"; +/// Format version of [`CONFIRMATIONS_FILE`]. +const CONFIRMATIONS_VERSION: u32 = 1; +/// Periodic reconciliation (on top of the triggers). Cards are re-signed by +/// the overlay's own maintenance every 10 minutes; this pass catches share +/// decisions that changed while the overlay was busy or unreachable. +pub const RECONCILE_INTERVAL: Duration = Duration::from_secs(5 * 60); +/// Triggers within this window are handled by one pass (a "check all" +/// refresh finishes many feeds in a row). +pub const RECONCILE_DEBOUNCE: Duration = Duration::from_secs(1); + +/// The feed URLs a privacy confirmation covers: exactly the URLs of the card +/// the user was shown. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ConfirmedUrls { + pub feed_url: FeedUrl, + pub id_feed_url: Option, +} + +impl ConfirmedUrls { + pub fn of(card: &PodcastCardSpec) -> Self { + Self { + feed_url: card.feed_url.clone(), + id_feed_url: card.id_feed_url.clone(), + } + } +} + +#[derive(Debug, Default, Serialize, Deserialize)] +struct ConfirmationsFile { + version: u32, + confirmed: BTreeMap, +} + +/// Device-local record of "publish this feed URL although it looks +/// private" (`PodcastShareState::privacy_confirmed`). Not synced. +#[derive(Debug)] +pub struct ShareConfirmations { + /// `None`: in memory only (tests, or the podcast store is unavailable). + path: Option, + confirmed: Mutex>, +} + +impl ShareConfirmations { + /// Loads the confirmations at `path`. A missing file is empty; an + /// unreadable or unknown file is treated as empty too (the user is asked + /// again, which is the safe direction) and replaced on the next change. + pub fn open(path: PathBuf) -> Self { + let confirmed = match std::fs::read(&path) { + Ok(bytes) => match serde_json::from_slice::(&bytes) { + Ok(file) if file.version == CONFIRMATIONS_VERSION => file.confirmed, + Ok(file) => { + tracing::warn!( + version = file.version, + "podcast share confirmations have an unknown format; asking again" + ); + BTreeMap::new() + } + Err(err) => { + tracing::warn!( + "podcast share confirmations are unreadable; asking again: {err}" + ); + BTreeMap::new() + } + }, + Err(err) if err.kind() == std::io::ErrorKind::NotFound => BTreeMap::new(), + Err(err) => { + tracing::warn!("cannot read the podcast share confirmations; asking again: {err}"); + BTreeMap::new() + } + }; + Self { + path: Some(path), + confirmed: Mutex::new(confirmed), + } + } + + pub fn in_memory() -> Self { + Self { + path: None, + confirmed: Mutex::new(BTreeMap::new()), + } + } + + /// Whether the user confirmed publishing exactly these feed URLs. + pub fn is_confirmed(&self, card: &PodcastCardSpec) -> bool { + self.lock() + .get(&card.podcast_id) + .is_some_and(|urls| *urls == ConfirmedUrls::of(card)) + } + + /// Records the confirmation of `urls` (replacing an older one). + /// Blocking (writes the file). + pub fn confirm(&self, podcast_id: &PodcastId, urls: ConfirmedUrls) -> Result<()> { + let mut confirmed = self.lock(); + if confirmed.get(podcast_id) == Some(&urls) { + return Ok(()); + } + let mut next = confirmed.clone(); + next.insert(podcast_id.clone(), urls); + self.save(&next)?; + *confirmed = next; + Ok(()) + } + + /// Drops the confirmation of a podcast (sharing turned off or + /// unsubscribed here): sharing it again asks again. Blocking. + pub fn forget(&self, podcast_id: &PodcastId) -> Result<()> { + let mut confirmed = self.lock(); + if !confirmed.contains_key(podcast_id) { + return Ok(()); + } + let mut next = confirmed.clone(); + next.remove(podcast_id); + self.save(&next)?; + *confirmed = next; + Ok(()) + } + + fn save(&self, confirmed: &BTreeMap) -> Result<()> { + let Some(path) = &self.path else { + return Ok(()); + }; + let file = ConfirmationsFile { + version: CONFIRMATIONS_VERSION, + confirmed: confirmed.clone(), + }; + write_private(path, &serde_json::to_vec_pretty(&file)?) + .with_context(|| format!("saving {}", path.display())) + } + + fn lock(&self) -> std::sync::MutexGuard<'_, BTreeMap> { + self.confirmed + .lock() + .unwrap_or_else(PoisonError::into_inner) + } +} + +/// Atomically replaces `path`; the file holds feed URLs, so it is readable +/// by the user only (like the podcast database). +fn write_private(path: &Path, bytes: &[u8]) -> Result<()> { + if let Some(parent) = path.parent() { + std::fs::create_dir_all(parent)?; + } + let mut temp = tempfile::NamedTempFile::new_in(path.parent().unwrap_or(Path::new(".")))?; + std::io::Write::write_all(&mut temp, bytes)?; + temp.as_file().sync_all()?; + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt as _; + temp.as_file() + .set_permissions(std::fs::Permissions::from_mode(0o600))?; + } + temp.persist(path)?; + Ok(()) +} + +/// The confirmations file of the podcast store at `db_path`. +pub fn confirmations_path(db_path: &Path) -> PathBuf { + db_path.with_file_name(CONFIRMATIONS_FILE) +} + +// --------------------------------------------------------------------------- +// Cards and share states + +/// The card this device publishes for a subscription: channel metadata and +/// counters from the local catalog (refreshed from the feed), `feed_url` the +/// URL this device fetches, `id_feed_url` the origin URL the podcast id was +/// derived from. Bounded to the card limits. +fn catalog_card( + summary: &PodcastSummary, + subscription: &SubscriptionRecord, +) -> Result { + // Finds the origin URL in the register's alias set (FRID keeps it). + let derived = PodcastCardSpec::from_subscription(subscription)?; + let origin = derived + .id_feed_url + .clone() + .unwrap_or_else(|| derived.feed_url.clone()); + let meta = &summary.meta; + let card = PodcastCardSpec { + podcast_id: subscription.podcast_id.clone(), + feed_url: meta.feed_url.clone(), + id_feed_url: Some(origin), + title: meta.title.clone(), + author: meta.author.clone(), + description: meta.description.clone(), + image_url: meta.image_url.clone(), + link: meta.link.clone(), + language: None, + categories: Vec::new(), + episode_count: Some(u32::try_from(summary.episode_count).unwrap_or(u32::MAX)), + latest_episode_at_ms: summary.latest_published_at_ms, + } + .bounded(); + card.validate()?; + Ok(card) +} + +/// The card [`share_states`] would publish for `podcast_id` (whether or not +/// it is shared yet), for the share confirmation. `None` when there is no +/// subscription. +pub fn share_card(store: &PodcastStore, podcast_id: &PodcastId) -> Result> { + let (Some(summary), Some(subscription)) = + (store.podcast(podcast_id)?, store.subscription(podcast_id)?) + else { + return Ok(None); + }; + catalog_card(&summary, &subscription).map(Some) +} + +/// What enabling "share" would publish and whether it needs the user's +/// confirmation first. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ShareCheck { + pub urls: ConfirmedUrls, + /// `PodcastCardSpec::privacy_warnings` of the card. + pub warnings: Vec, + /// The user already confirmed exactly these URLs on this device. + pub confirmed: bool, +} + +impl ShareCheck { + /// Sharing must be confirmed in a dialog first. + pub fn needs_confirmation(&self) -> bool { + !self.warnings.is_empty() && !self.confirmed + } +} + +/// Builds the [`ShareCheck`] of a subscribed podcast. Blocking. +pub fn check_share( + store: &PodcastStore, + confirmations: &ShareConfirmations, + podcast_id: &PodcastId, +) -> Result { + let card = share_card(store, podcast_id)? + .with_context(|| "the podcast is not subscribed".to_string())?; + Ok(ShareCheck { + urls: ConfirmedUrls::of(&card), + warnings: card.privacy_warnings(), + confirmed: confirmations.is_confirmed(&card), + }) +} + +/// One `PodcastShareState` per podcast with a subscription register, the +/// input of `PodcastDht::sync_shares`. Blocking. +/// +/// Only podcasts for which `effective_share` holds get a card; for every +/// other podcast `card` is `None` and `privacy_confirmed` false, so no +/// private metadata is prepared for publication at all. +pub fn share_states( + store: &PodcastStore, + confirmations: &ShareConfirmations, +) -> Result> { + let mut states = Vec::new(); + for summary in store.list_podcasts(PodcastListFilter::All)? { + let podcast_id = &summary.podcast_id; + let Some(subscription) = store.subscription(podcast_id)? else { + continue; + }; + let share = store.share(podcast_id)?; + let shared = effective_share(Some(&subscription), share.as_ref()); + // A card that cannot be built from the catalog falls back to the + // one `sync_shares` derives from the register (and fails there, + // reported, if that is impossible too). + let card = if shared { + catalog_card(&summary, &subscription) + .inspect_err(|err| tracing::debug!("podcast card from the catalog: {err:#}")) + .ok() + } else { + None + }; + let privacy_confirmed = card + .as_ref() + .is_some_and(|card| confirmations.is_confirmed(card)); + states.push(PodcastShareState { + subscription, + share, + card, + privacy_confirmed, + }); + } + Ok(states) +} + +// --------------------------------------------------------------------------- +// Reconciliation + +/// Public discovery as this device runs it. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub enum Discovery { + /// No reconciliation finished yet. + #[default] + Starting, + /// Nothing is published from this device; the reason. + Off(String), + /// The overlay runs; `peers` overlay contacts are known. + Running { peers: usize }, +} + +/// Publication of one shared podcast from this device. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum Publication { + /// This device's card is published (signed, stored by the replicas it + /// reached and republished every 10 minutes). + Published, + /// Shared, but not yet published here (for example the overlay has not + /// accepted it yet). + Pending, + /// Shared, but held back on this device until its user confirms the + /// feed URLs that look private. + HeldBack(Vec), + /// The card could not be built, signed or published. + Failed(String), +} + +/// Result of one reconciliation, for the Podcasts tab. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct PublicationReport { + pub discovery: Discovery, + /// Shared podcasts only. + pub podcasts: BTreeMap, + /// The pass as a whole failed (store or overlay error). + pub error: Option, +} + +/// Reconciles this device's publications with the share registers of +/// `store` once. Without a store (it could not be opened) every own +/// publication is revoked: this device can no longer tell what the user +/// still shares, and revoking is the privacy-safe direction. The same holds +/// when the registers cannot be read. +pub async fn reconcile( + dht: &PodcastDht, + store: Option>, + confirmations: Arc, +) -> PublicationReport { + let mut report = PublicationReport { + discovery: Discovery::Running { + peers: dht.known_peers(), + }, + ..PublicationReport::default() + }; + // Why every own card is revoked, when the registers are unknown. + let mut revoke_all: Option = None; + let states = match store { + Some(store) => { + match tokio::task::spawn_blocking(move || share_states(&store, &confirmations)).await { + Ok(Ok(states)) => states, + Ok(Err(err)) => { + revoke_all = Some(format!("cannot read share decisions ({err:#})")); + Vec::new() + } + Err(err) => { + revoke_all = Some(format!("cannot read share decisions ({err})")); + Vec::new() + } + } + } + None => { + revoke_all = Some("the podcast database is unavailable".into()); + Vec::new() + } + }; + let shared: Vec = states + .iter() + .filter(|state| state.is_shared()) + .map(|state| state.subscription.podcast_id.clone()) + .collect(); + let stats = match dht.sync_shares(states).await { + Ok(stats) => stats, + Err(err) => { + tracing::warn!("podcast publication failed: {err}"); + report.error = Some(format!("publication failed: {err}")); + for podcast_id in shared { + report + .podcasts + .insert(podcast_id, Publication::Failed(err.to_string())); + } + return report; + } + }; + if stats.published + stats.unpublished + stats.failed.len() > 0 { + tracing::info!( + published = stats.published, + unchanged = stats.unchanged, + unpublished = stats.unpublished, + held_back = stats.held_back.len(), + failed = stats.failed.len(), + remote_nodes = stats.push.remote_nodes, + "podcast publications reconciled" + ); + } + for failure in &stats.failed { + // Failures may concern revoked (now private) podcasts: no ids. + tracing::warn!(error = %failure.error, "podcast publication step failed"); + } + if let Some(reason) = revoke_all { + // Worth telling the user only when something was published. + if stats.unpublished > 0 || !stats.failed.is_empty() { + tracing::warn!( + unpublished = stats.unpublished, + "podcast publication: {reason}; own public cards revoked" + ); + report.error = Some(format!("{reason}; own public cards revoked")); + } else { + tracing::debug!("podcast publication: {reason}; nothing is published"); + } + } + let active: BTreeSet = match dht.published().await { + Ok(published) => published + .into_iter() + .filter(|publication| publication.active) + .map(|publication| publication.podcast_id) + .collect(), + Err(err) => { + report.error = Some(format!("cannot read own publications: {err}")); + BTreeSet::new() + } + }; + let held: BTreeMap> = stats + .held_back + .into_iter() + .map(|hold| (hold.podcast_id, hold.warnings)) + .collect(); + let failed: BTreeMap = stats + .failed + .into_iter() + .map(|failure| (failure.podcast_id, failure.error)) + .collect(); + for podcast_id in shared { + let publication = if let Some(warnings) = held.get(&podcast_id) { + Publication::HeldBack(warnings.clone()) + } else if let Some(error) = failed.get(&podcast_id) { + Publication::Failed(error.clone()) + } else if active.contains(&podcast_id) { + Publication::Published + } else { + Publication::Pending + }; + report.podcasts.insert(podcast_id, publication); + } + report +} + +/// Wakes the running reconciler. +#[derive(Debug, Clone)] +pub struct Reconciler { + wake: Arc, +} + +impl Reconciler { + /// Requests a reconciliation soon (after [`RECONCILE_DEBOUNCE`]). A + /// request during a pass is kept and runs another pass afterwards. + pub fn wake(&self) { + self.wake.notify_one(); + } +} + +/// Runs the reconciler until the overlay watch closes. `dht` follows the +/// federation node; while it is `None` nothing is published from this +/// device and `report` says so. +pub fn spawn( + mut dht: watch::Receiver>>, + store: Option>, + confirmations: Arc, + report: impl Fn(PublicationReport) + Send + 'static, +) -> Reconciler { + let wake = Arc::new(Notify::new()); + let reconciler = Reconciler { + wake: Arc::clone(&wake), + }; + tokio::spawn(async move { + loop { + let current = dht.borrow_and_update().clone(); + match current { + Some(dht) => { + let pass = reconcile(&dht, store.clone(), Arc::clone(&confirmations)).await; + report(pass); + } + None => report(PublicationReport { + discovery: Discovery::Off( + "federation is off or podcast discovery is unavailable".into(), + ), + ..PublicationReport::default() + }), + } + tokio::select! { + _ = wake.notified() => tokio::time::sleep(RECONCILE_DEBOUNCE).await, + changed = dht.changed() => { + if changed.is_err() { + return; + } + } + _ = tokio::time::sleep(RECONCILE_INTERVAL) => {} + } + } + }); + reconciler +} + +/// Russian text of a privacy warning, for the share confirmation dialog. +pub fn warning_ru(warning: &FeedUrlPrivacyWarning) -> String { + match warning { + FeedUrlPrivacyWarning::SecretQueryParameter { name } => { + format!("в адресе ленты есть параметр «{name}», похожий на ключ доступа") + } + FeedUrlPrivacyWarning::PrivateFeedHost { host } => { + format!("{host} обычно выдаёт личные ленты для платных подписчиков") + } + FeedUrlPrivacyWarning::HighEntropyQueryValue { name } => { + format!("значение параметра «{name}» похоже на секретный токен") + } + FeedUrlPrivacyWarning::HighEntropyPathSegment { index } => { + format!("часть пути адреса №{} похожа на секретный токен", index + 1) + } + other => other.to_string(), + } +} diff --git a/src/podcasts/publication_tests.rs b/src/podcasts/publication_tests.rs new file mode 100644 index 0000000..29a77e1 --- /dev/null +++ b/src/podcasts/publication_tests.rs @@ -0,0 +1,476 @@ +//! Publication of shared podcasts: share states built from the store, the +//! local privacy confirmations, and a two-node loopback test of the real +//! discovery overlay (no internet, temp directories only). + +use std::sync::Arc; +use std::time::Duration; + +use anyhow::Result; +use furumi_library::podcasts::{OpStamp, PodcastLocalOp, PodcastStore, StampSource}; +use music_dht::device_sync::SyncOpWire; +use music_dht::podcast::{FeedUrl, PodcastId, PodcastMeta}; +use music_dht::podcast_dht::{FeedUrlPrivacyWarning, PODCAST_DHT_ALPN, PodcastDht}; +use music_dht::{MusicDhtConfig, MusicDhtService, NetworkId}; + +use super::publication::{ + Discovery, Publication, PublicationReport, ShareConfirmations, check_share, reconcile, + share_card, share_states, warning_ru, +}; + +const SHOW_URL: &str = "https://feeds.example.test/rust-radio.xml"; +const SECRET_URL: &str = "https://feeds.example.test/members.xml?token=0123456789abcdef"; +const PRIVATE_URL: &str = "https://feeds.example.test/diary.xml"; + +/// Stamps of one device's local actions; keeps the operations they emit. +struct Device { + id: &'static str, + seq: i64, + ops: Vec, +} + +struct Stamps<'a> { + device: &'a str, + next: i64, +} + +impl StampSource for Stamps<'_> { + fn device_id(&self) -> &str { + self.device + } + + fn next_stamp(&mut self) -> Result { + self.next += 1; + Ok(OpStamp::new( + format!("{}:{}", self.device, self.next), + self.device, + 1_700_000_000_000 + self.next, + )) + } +} + +impl Device { + fn new(id: &'static str) -> Self { + Self { + id, + seq: 0, + ops: Vec::new(), + } + } + + fn act( + &mut self, + action: impl FnOnce(&mut dyn StampSource) -> Result>, + ) -> Vec { + let mut stamps = Stamps { + device: self.id, + next: self.seq, + }; + let ops = action(&mut stamps).unwrap(); + let mut wires = Vec::new(); + for op in ops { + self.seq += 1; + wires.push(op.into_wire(self.seq)); + } + self.ops.extend(wires.iter().cloned()); + wires + } + + fn subscribe(&mut self, store: &PodcastStore, url: &str, title: &str) -> PodcastId { + let meta = PodcastMeta { + feed_url: FeedUrl::parse(url).unwrap(), + title: title.to_string(), + author: Some("Ferris Crab".to_string()), + description: Some("Weekly news.".to_string()), + link: None, + image_url: None, + }; + let mut id = None; + self.act(|stamps| { + let outcome = store.subscribe(stamps, &meta)?; + id = Some(outcome.podcast_id); + Ok(outcome.ops) + }); + id.unwrap() + } + + fn set_shared( + &mut self, + store: &PodcastStore, + id: &PodcastId, + shared: bool, + ) -> Vec { + self.act(|stamps| store.set_shared(stamps, id, shared)) + } + + fn unsubscribe(&mut self, store: &PodcastStore, id: &PodcastId) { + self.act(|stamps| store.unsubscribe(stamps, id)); + } +} + +fn shared_ids(store: &PodcastStore, confirmations: &ShareConfirmations) -> Vec { + share_states(store, confirmations) + .unwrap() + .into_iter() + .filter(|state| state.is_shared()) + .map(|state| state.subscription.podcast_id) + .collect() +} + +#[test] +fn share_states_carry_cards_only_for_shared_podcasts() { + let store = PodcastStore::open_in_memory().unwrap(); + let confirmations = ShareConfirmations::in_memory(); + let mut device = Device::new("device-a"); + let show = device.subscribe(&store, SHOW_URL, "Rust Radio Weekly"); + let diary = device.subscribe(&store, PRIVATE_URL, "Secret Garden Diaries"); + + // A new subscription is private: no state is shared, no card is built. + let states = share_states(&store, &confirmations).unwrap(); + assert_eq!(states.len(), 2); + assert!(states.iter().all(|state| !state.is_shared())); + assert!(states.iter().all(|state| state.card.is_none())); + + device.set_shared(&store, &show, true); + let states = share_states(&store, &confirmations).unwrap(); + let shown = states + .iter() + .find(|state| state.subscription.podcast_id == show) + .unwrap(); + assert!(shown.is_shared()); + let card = shown.card.clone().unwrap(); + assert_eq!(card.feed_url, FeedUrl::parse(SHOW_URL).unwrap()); + assert_eq!(card.id_feed_url, None, "the feed did not move"); + assert_eq!(card.title, "Rust Radio Weekly"); + assert_eq!(card.episode_count, Some(0)); + assert!(!shown.privacy_confirmed); + let private = states + .iter() + .find(|state| state.subscription.podcast_id == diary) + .unwrap(); + assert!(!private.is_shared()); + assert!(private.card.is_none()); + assert_eq!(shared_ids(&store, &confirmations), vec![show.clone()]); + + // Share off and unsubscribe both make the podcast private again. + device.set_shared(&store, &show, false); + assert!(shared_ids(&store, &confirmations).is_empty()); + device.set_shared(&store, &show, true); + assert_eq!(shared_ids(&store, &confirmations), vec![show.clone()]); + device.unsubscribe(&store, &show); + assert!(shared_ids(&store, &confirmations).is_empty()); + // Subscribing again is private until shared again. + device.subscribe(&store, SHOW_URL, "Rust Radio Weekly"); + assert!(shared_ids(&store, &confirmations).is_empty()); +} + +#[test] +fn a_stale_share_decision_from_another_device_does_not_republish() { + let store = PodcastStore::open_in_memory().unwrap(); + let confirmations = ShareConfirmations::in_memory(); + let mut device = Device::new("device-a"); + let show = device.subscribe(&store, SHOW_URL, "Rust Radio Weekly"); + let shared = device.set_shared(&store, &show, true); + + // Another trusted device turns sharing off; its operation arrives here. + let other = PodcastStore::open_in_memory().unwrap(); + for op in &device.ops { + other.apply_remote_op(op).unwrap(); + } + let mut device_b = Device::new("device-b"); + let revoke = device_b.set_shared(&other, &show, false); + for op in &revoke { + store.apply_remote_op(op).unwrap(); + } + assert!(shared_ids(&store, &confirmations).is_empty()); + + // The old "share" decision delivered again (a late device) loses. + for op in &shared { + store.apply_remote_op(op).unwrap(); + } + assert!(shared_ids(&store, &confirmations).is_empty()); +} + +#[test] +fn privacy_confirmations_are_local_and_bound_to_the_urls() { + let temp = tempfile::tempdir().unwrap(); + let path = temp.path().join("podcast-share-confirmations.json"); + let store = PodcastStore::open_in_memory().unwrap(); + let mut device = Device::new("device-a"); + let secret = device.subscribe(&store, SECRET_URL, "Members Only"); + let show = device.subscribe(&store, SHOW_URL, "Rust Radio Weekly"); + + let confirmations = ShareConfirmations::open(path.clone()); + let check = check_share(&store, &confirmations, &show).unwrap(); + assert!(check.warnings.is_empty()); + assert!(!check.needs_confirmation()); + + let check = check_share(&store, &confirmations, &secret).unwrap(); + assert!(check.needs_confirmation()); + assert!(matches!( + check.warnings.as_slice(), + [FeedUrlPrivacyWarning::SecretQueryParameter { name }] if name == "token" + )); + assert_eq!( + warning_ru(&check.warnings[0]), + "в адресе ленты есть параметр «token», похожий на ключ доступа" + ); + confirmations.confirm(&secret, check.urls.clone()).unwrap(); + + // Persisted on this device, read again after a restart. + let reopened = ShareConfirmations::open(path.clone()); + let check = check_share(&store, &reopened, &secret).unwrap(); + assert!(check.confirmed); + assert!(!check.needs_confirmation()); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt as _; + let mode = std::fs::metadata(&path).unwrap().permissions().mode(); + assert_eq!(mode & 0o077, 0, "only the user may read the feed URLs"); + } + + // Other URLs (the feed moved) are not covered. + let card = share_card(&store, &secret).unwrap().unwrap(); + let moved = music_dht::podcast_dht::PodcastCardSpec { + feed_url: FeedUrl::parse("https://feeds.example.test/members.xml?token=ffffffffffffffff") + .unwrap(), + id_feed_url: Some(card.feed_url.clone()), + ..card.clone() + }; + assert!(reopened.is_confirmed(&card)); + assert!(!reopened.is_confirmed(&moved)); + + // Shared but held: the confirmation is used by the share state. + device.set_shared(&store, &secret, true); + let state = share_states(&store, &reopened) + .unwrap() + .into_iter() + .find(|state| state.subscription.podcast_id == secret) + .unwrap(); + assert!(state.privacy_confirmed); + + reopened.forget(&secret).unwrap(); + assert!(!ShareConfirmations::open(path.clone()).is_confirmed(&card)); + + // A corrupt file asks again instead of failing. + std::fs::write(&path, b"{not json").unwrap(); + assert!(!ShareConfirmations::open(path).is_confirmed(&card)); +} + +// --------------------------------------------------------------------------- +// Two loopback nodes + +struct Node { + service: Arc, + dht: Arc, + tasks: Vec>, +} + +impl Node { + async fn start(directory: &std::path::Path, network: NetworkId) -> Self { + std::fs::create_dir_all(directory).unwrap(); + let config = MusicDhtConfig::builder() + .data_dir(directory) + .network_id(network) + .request_timeout(Duration::from_secs(2)) + .lookup_timeout(Duration::from_secs(5)) + .transport_timeout(Duration::from_secs(5)) + .dial_timeout(Duration::from_secs(2)) + .schema_independent_stream_protocol(PODCAST_DHT_ALPN) + .build() + .unwrap(); + let (service, mut events) = MusicDhtService::start(config).await.unwrap(); + let service = Arc::new(service); + let events = tokio::spawn(async move { while events.recv().await.is_some() {} }); + // Same wiring as `federation::open_podcast_dht`. + let acceptor = service.stream_acceptor(PODCAST_DHT_ALPN).unwrap(); + let dht = PodcastDht::open( + Arc::clone(&service), + directory.join(crate::federation::PODCAST_DHT_CACHE_FILE), + ) + .await + .unwrap(); + let serve = tokio::spawn(Arc::clone(&dht).serve(acceptor)); + Self { + service, + dht, + tasks: vec![events, serve], + } + } + + async fn stop(self) { + for task in &self.tasks { + task.abort(); + } + self.service.shutdown().await.unwrap(); + } +} + +async fn wait_for(what: &str, mut check: impl AsyncFnMut() -> Option) -> T { + let started = std::time::Instant::now(); + loop { + if let Some(value) = check().await { + return value; + } + assert!( + started.elapsed() < Duration::from_secs(60), + "timed out waiting for {what}" + ); + tokio::time::sleep(Duration::from_millis(300)).await; + } +} + +async fn found(node: &Node, id: &PodcastId) -> bool { + node.dht.lookup_podcast(id).await.unwrap().is_some() +} + +fn publication(report: &PublicationReport, id: &PodcastId) -> Option { + report.podcasts.get(id).cloned() +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 4)] +async fn shared_podcast_is_found_by_a_stranger_and_revoked_by_share_off() { + tokio::time::timeout(Duration::from_secs(240), two_nodes()) + .await + .unwrap(); +} + +async fn two_nodes() { + let temp = tempfile::tempdir().unwrap(); + let network = NetworkId::from_name("furumi-tui-podcast-publication-test"); + // A: this TUI with its podcast store. C: a stranger outside A's + // trusted-device group (no device sync at all). + let a = Node::start(&temp.path().join("a"), network).await; + let c = Node::start(&temp.path().join("c"), network).await; + c.service + .connect(a.service.ticket().await.unwrap()) + .await + .unwrap(); + wait_for("music DHT contacts", async || { + (!a.service.known_peers().is_empty() && !c.service.known_peers().is_empty()).then_some(()) + }) + .await; + for node in [&a, &c] { + node.dht.bootstrap().await.unwrap(); + } + wait_for("overlay contacts", async || { + (a.dht.known_peers() >= 1 && c.dht.known_peers() >= 1).then_some(()) + }) + .await; + + let store = Arc::new(PodcastStore::open_in_memory().unwrap()); + let confirmations = Arc::new(ShareConfirmations::open( + temp.path().join("podcast-share-confirmations.json"), + )); + let mut device = Device::new("device-a"); + let show = device.subscribe(&store, SHOW_URL, "Rust Radio Weekly"); + let diary = device.subscribe(&store, PRIVATE_URL, "Secret Garden Diaries"); + let secret = device.subscribe(&store, SECRET_URL, "Members Only Show"); + + // Nothing is shared yet: nothing is published. + let report = reconcile(&a.dht, Some(Arc::clone(&store)), Arc::clone(&confirmations)).await; + assert_eq!(report.error, None); + assert!(report.podcasts.is_empty()); + assert!(a.dht.published().await.unwrap().is_empty()); + + // A shares two podcasts; the one with a private-looking URL is held + // back until confirmed on this device. + device.set_shared(&store, &show, true); + device.set_shared(&store, &secret, true); + let report = reconcile(&a.dht, Some(Arc::clone(&store)), Arc::clone(&confirmations)).await; + assert_eq!(report.error, None); + assert!(matches!(report.discovery, Discovery::Running { peers } if peers >= 1)); + assert_eq!(publication(&report, &show), Some(Publication::Published)); + assert!(matches!( + publication(&report, &secret), + Some(Publication::HeldBack(warnings)) if !warnings.is_empty() + )); + assert_eq!(publication(&report, &diary), None); + + // The stranger finds the shared card by text and by id ... + let hits = wait_for("the shared card", async || { + let hits = c.dht.search("rust radio", 10).await.unwrap(); + (!hits.is_empty()).then_some(hits) + }) + .await; + assert_eq!(hits.len(), 1); + assert_eq!(hits[0].podcast_id, show); + assert_eq!(hits[0].feed_url, FeedUrl::parse(SHOW_URL).unwrap()); + assert_eq!(hits[0].publishers, vec![a.service.endpoint_id()]); + assert!(found(&c, &show).await); + // ... but neither the private subscription nor the held-back one. + assert!(!found(&c, &diary).await); + assert!(c.dht.search("secret garden", 10).await.unwrap().is_empty()); + assert!(!found(&c, &secret).await); + assert!(c.dht.search("members only", 10).await.unwrap().is_empty()); + + // Confirming exactly the URLs shown publishes the held-back podcast. + let check = check_share(&store, &confirmations, &secret).unwrap(); + confirmations.confirm(&secret, check.urls).unwrap(); + let report = reconcile(&a.dht, Some(Arc::clone(&store)), Arc::clone(&confirmations)).await; + assert_eq!(publication(&report, &secret), Some(Publication::Published)); + wait_for("the confirmed card", async || { + found(&c, &secret).await.then_some(()) + }) + .await; + + // Sharing off: the tombstone wins over the card at the stranger. + let shared_op = device.ops.clone(); + device.set_shared(&store, &show, false); + let report = reconcile(&a.dht, Some(Arc::clone(&store)), Arc::clone(&confirmations)).await; + assert_eq!(publication(&report, &show), None); + assert!(!found(&c, &show).await, "the tombstone hides the card"); + assert!(c.dht.search("rust radio", 10).await.unwrap().is_empty()); + let own = a.dht.published().await.unwrap(); + assert!( + own.iter() + .any(|publication| publication.podcast_id == show && !publication.active) + ); + + // A late copy of the old "share" operation does not republish it. + for op in &shared_op { + store.apply_remote_op(op).unwrap(); + } + let report = reconcile(&a.dht, Some(Arc::clone(&store)), Arc::clone(&confirmations)).await; + assert_eq!(publication(&report, &show), None); + assert!(!found(&c, &show).await); + + // Unsubscribing revokes too. + device.unsubscribe(&store, &secret); + let report = reconcile(&a.dht, Some(Arc::clone(&store)), Arc::clone(&confirmations)).await; + assert!(report.podcasts.is_empty()); + assert!(!found(&c, &secret).await); + + // Without a podcast store (it failed to open) every own card is revoked. + device.subscribe(&store, SECRET_URL, "Members Only Show"); + device.set_shared(&store, &secret, true); + confirmations + .confirm( + &secret, + check_share(&store, &confirmations, &secret).unwrap().urls, + ) + .unwrap(); + let report = reconcile(&a.dht, Some(Arc::clone(&store)), Arc::clone(&confirmations)).await; + assert_eq!(publication(&report, &secret), Some(Publication::Published)); + wait_for("the republished card", async || { + found(&c, &secret).await.then_some(()) + }) + .await; + let report = reconcile(&a.dht, None, Arc::clone(&confirmations)).await; + assert!(report.error.is_some()); + assert!(report.podcasts.is_empty()); + // Nothing left to revoke: no error to show again. + let report = reconcile(&a.dht, None, Arc::clone(&confirmations)).await; + assert_eq!(report.error, None); + assert!(!found(&c, &secret).await); + assert!( + a.dht + .published() + .await + .unwrap() + .iter() + .all(|publication| !publication.active) + ); + + a.stop().await; + c.stop().await; +} diff --git a/src/podcasts/refresh.rs b/src/podcasts/refresh.rs index f4ddfd9..1362aca 100644 --- a/src/podcasts/refresh.rs +++ b/src/podcasts/refresh.rs @@ -30,6 +30,8 @@ pub struct Services { pub store: Arc, pub fetcher: Arc, pub log: Arc, + /// Device-local privacy confirmations for sharing (never synced). + pub confirmations: Arc, } impl std::fmt::Debug for Services {