diff --git a/src/app/podcast_runtime.rs b/src/app/podcast_runtime.rs index a1ba736..4ccb9f4 100644 --- a/src/app/podcast_runtime.rs +++ b/src/app/podcast_runtime.rs @@ -157,13 +157,22 @@ fn wake_publication(runtime: &Runtime) { } } -/// Asks the publication reconciler for an immediate pass: a card must be -/// revoked (sharing turned off or unsubscribed here). Quitting waits for -/// it, bounded ([`PUBLICATION_FLUSH_TIMEOUT`]). -fn revoke_publication(runtime: &Runtime) { - if let Some(podcasts) = &runtime.podcasts { - podcasts.publication.revoke_now(); - } +/// A card may have to be revoked (sharing turned off or unsubscribed here): +/// the write about to start ends with an immediate reconciler pass +/// ([`publication::RevocationTicket::done`]), and quitting waits for both, +/// bounded ([`PUBLICATION_FLUSH_TIMEOUT`]), even when it is handled before +/// the write finished. +fn begin_revocation(runtime: &Runtime) -> Option { + runtime + .podcasts + .as_ref() + .map(|podcasts| podcasts.publication.begin_revocation()) +} + +/// Whether `podcast_id` is shared now (a card from this device may be +/// live), read before a share-off or unsubscribe is written. Blocking. +fn shared_now(services: &Services, podcast_id: &music_dht::podcast::PodcastId) -> bool { + matches!(services.store.podcast(podcast_id), Ok(Some(summary)) if summary.shared) } fn services(runtime: &Runtime) -> Option { @@ -283,9 +292,11 @@ pub fn perform(state: &mut AppState, runtime: &mut Runtime, effect: Effect) -> O } } Effect::PodcastUnsubscribe { podcast_id, title } => { + let revocation = begin_revocation(runtime); tokio::task::spawn_blocking(move || { let store = Arc::clone(&services.store); let id = podcast_id.clone(); + let was_shared = shared_now(&services, &podcast_id); let result = services .log .record(&mut |stamps| store.unsubscribe(stamps, &id)) @@ -297,6 +308,12 @@ pub fn perform(state: &mut AppState, runtime: &mut Runtime, effect: Effect) -> O { tracing::warn!("podcast share confirmation not removed: {err:#}"); } + // Unsubscribing revokes this device's card, right away. + if let Some(revocation) = revocation + && result.is_ok() + { + revocation.done(was_shared.then_some(&podcast_id)); + } let _ = tx.send(AppEvent::PodcastUnsubscribed { podcast_id, title, @@ -337,9 +354,20 @@ pub fn perform(state: &mut AppState, runtime: &mut Runtime, effect: Effect) -> O shared, confirm, } => { + let revocation = if shared { + None + } else { + begin_revocation(runtime) + }; tokio::task::spawn_blocking(move || { + let was_shared = !shared && shared_now(&services, &podcast_id); let result = set_shared(&services, &podcast_id, shared, confirm).map_err(err_string); + if let Some(revocation) = revocation + && result.is_ok() + { + revocation.done(was_shared.then_some(&podcast_id)); + } let _ = tx.send(AppEvent::PodcastShareSet { podcast_id, title, @@ -488,10 +516,7 @@ pub fn handle_event( title, result, } => { - // Unsubscribing revokes this device's card, right away. - if result.is_ok() { - revoke_publication(runtime); - } + // The blocking write already asked for the revocation pass. podcasts::unsubscribed(state, podcast_id, title, result) .into_iter() .collect() @@ -509,9 +534,9 @@ pub fn handle_event( shared, result, } => { - if !shared && result.is_ok() { - revoke_publication(runtime); - } else { + // A share-off already asked for its revocation pass when it + // was written. + if shared || result.is_err() { wake_publication(runtime); } podcasts::share_set(state, podcast_id, title, shared, result) @@ -1116,8 +1141,9 @@ fn progress_event( /// Before exit (before the federation node stops): end the playing /// episode's session and give the progress writer a moment to save it, and -/// let a revocation requested just before (sharing turned off, unsubscribed) -/// reach the overlay. +/// let a revocation requested just before (sharing turned off, unsubscribed; +/// also one still being written) reach the overlay. Logs a warning when a +/// card of a private podcast may still be live. pub(crate) async fn shutdown(runtime: &mut Runtime) { end_playback(runtime); let Some(podcasts) = runtime.podcasts.as_mut() else { diff --git a/src/app/update/podcasts.rs b/src/app/update/podcasts.rs index 9cbd5ca..188e522 100644 --- a/src/app/update/podcasts.rs +++ b/src/app/update/podcasts.rs @@ -806,7 +806,7 @@ pub fn share_set( Some(Effect::PodcastsReload) } Ok(()) => { - state.podcasts.publication.note_revocation(&podcast_id); + note_revocation(state, &podcast_id); state.status_message = Some(format!( "podcasts: {title} is private again; the public card is being revoked" )); @@ -819,6 +819,21 @@ pub fn share_set( } } +/// Sharing of `podcast_id` was turned off or it was unsubscribed here: its +/// card counts as not revoked until a pass says otherwise +/// (`PublicationReport::note_revocation`; the row is not reloaded yet, so it +/// still says whether the podcast was shared). +fn note_revocation(state: &mut AppState, podcast_id: &PodcastId) { + let was_shared = state + .podcasts + .podcast(podcast_id) + .is_some_and(|row| row.summary.shared); + state + .podcasts + .publication + .note_revocation(podcast_id, was_shared); +} + /// A publication reconciler pass finished. Errors go to the status bar /// when they are new (the log has them too). pub fn publication_reported(state: &mut AppState, report: PublicationReport) { @@ -1153,7 +1168,7 @@ pub fn unsubscribed( ) -> Option { match result { Ok(()) => { - state.podcasts.publication.note_revocation(&podcast_id); + note_revocation(state, &podcast_id); state.status_message = Some(format!( "podcasts: unsubscribed from {}; progress and history are kept", display_title(&title) diff --git a/src/app/update_tests.rs b/src/app/update_tests.rs index 39be1dc..a3e3a16 100644 --- a/src/app/update_tests.rs +++ b/src/app/update_tests.rs @@ -2008,6 +2008,7 @@ mod podcast_tab { let effect = podcasts::share_set(&mut state, podcast_id(), "Show".into(), false, Ok(())); assert_eq!(effect, Some(Effect::PodcastsReload)); assert!(state.podcasts.publication.podcasts.is_empty()); + assert!(state.podcasts.publication.unrevoked.contains(&podcast_id())); assert!( state .status_message @@ -2015,6 +2016,29 @@ mod podcast_tab { .is_some_and(|m| m.contains("private again")) ); + // The federation is off (since the start, or the app was restarted + // since the card was published): no pass knows whether a card from + // an earlier session is live, so one that was shared counts as not + // revoked yet, for share-off and unsubscribe alike. + for discovery in [ + Discovery::Off("federation is off".into()), + Discovery::Starting, + ] { + let mut state = ready(vec![shared_row()]); + state.podcasts.publication.discovery = discovery.clone(); + podcasts::share_set(&mut state, podcast_id(), "Show".into(), false, Ok(())); + assert!(state.podcasts.publication.unrevoked.contains(&podcast_id())); + let mut state = ready(vec![shared_row()]); + state.podcasts.publication.discovery = discovery.clone(); + podcasts::unsubscribed(&mut state, podcast_id(), "Show".into(), Ok(())); + assert!(state.podcasts.publication.unrevoked.contains(&podcast_id())); + // A podcast that was not shared has no card to revoke. + let mut state = ready(vec![fx::row("Show", 0, 1, 0)]); + state.podcasts.publication.discovery = discovery; + podcasts::unsubscribed(&mut state, podcast_id(), "Show".into(), Ok(())); + assert!(state.podcasts.publication.unrevoked.is_empty()); + } + // Shared (for example from another device) but held back here: the // key asks for this device's confirmation instead of unsharing. let mut state = ready(vec![shared_row()]); diff --git a/src/podcasts/publication.rs b/src/podcasts/publication.rs index 8376773..1beafdc 100644 --- a/src/podcasts/publication.rs +++ b/src/podcasts/publication.rs @@ -18,10 +18,11 @@ //! 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. +//! * [`spawn`] runs the reconciler off the UI thread: right after local +//! share-off and unsubscribe actions (quitting waits for those, +//! [`Reconciler::flush`]), after other local share actions, received +//! podcast operations and 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 @@ -665,12 +666,24 @@ pub struct PublicationReport { impl PublicationReport { /// Sharing of `podcast_id` was turned off (or it was unsubscribed) on - /// this device: until the next pass says otherwise, a card it may have - /// published counts as not revoked yet. - pub fn note_revocation(&mut self, podcast_id: &PodcastId) { - if let Some(publication) = self.podcasts.remove(podcast_id) - && !matches!(publication, Publication::HeldBack(_)) - { + /// this device; `was_shared`: it was shared just before. Until the next + /// pass says otherwise, a card this device may have published counts as + /// not revoked yet. + /// + /// While the overlay runs, the last pass says whether a card was + /// published (a held-back one never was). Without a pass of the running + /// overlay (federation off, or not started yet) this device cannot tell + /// whether a card from an earlier session is still live, so a podcast + /// that was shared counts as not revoked. + pub fn note_revocation(&mut self, podcast_id: &PodcastId, was_shared: bool) { + let publication = self.podcasts.remove(podcast_id); + let maybe_live = match self.discovery { + Discovery::Running { .. } => publication.map_or(was_shared, |publication| { + !matches!(publication, Publication::HeldBack(_)) + }), + Discovery::Off(_) | Discovery::Starting => was_shared, + }; + if maybe_live { self.unrevoked.insert(podcast_id.clone()); } } @@ -850,9 +863,46 @@ pub struct Reconciler { urgent: Arc, /// Number of revocations requested so far. revocations: Arc, - /// Revocations covered by a finished pass (or by a pass that found the - /// overlay off, when nothing can be sent). - covered: watch::Receiver, + /// Revocations whose decision is still being written + /// ([`Reconciler::begin_revocation`]). + in_flight: Arc>, + /// Podcasts revoked here that were shared just before, not yet seen by + /// a pass. A pass without the overlay keeps them as not revoked. + revoked: Arc>>, + /// The latest finished pass. + covered: watch::Receiver, +} + +/// What the latest finished pass covered. +#[derive(Debug, Clone, Copy, Default)] +struct Covered { + /// Revocations requested before it started. + revocations: u64, + /// Cards of private podcasts it found (or kept as) not revoked. + unrevoked: usize, +} + +/// A share-off or unsubscribe being written: quitting waits for it +/// ([`Reconciler::flush`]). Dropping it without [`RevocationTicket::done`] +/// means the decision was not written. +#[derive(Debug)] +pub struct RevocationTicket { + reconciler: Reconciler, +} + +impl RevocationTicket { + /// The decision was written: revoke now ([`Reconciler::revoke_now`]). + pub fn done(self, was_shared: Option<&PodcastId>) { + self.reconciler.revoke_now(was_shared); + } +} + +impl Drop for RevocationTicket { + fn drop(&mut self) { + self.reconciler + .in_flight + .send_modify(|in_flight| *in_flight = in_flight.saturating_sub(1)); + } } impl Reconciler { @@ -862,38 +912,99 @@ impl Reconciler { self.wake.notify_one(); } + /// A share-off or unsubscribe is about to be written (off the UI + /// thread): from now on, quitting waits for it to be written and + /// revoked. Call before starting the write, so a quit that is handled + /// before the write finishes still waits. + pub fn begin_revocation(&self) -> RevocationTicket { + self.in_flight.send_modify(|in_flight| *in_flight += 1); + RevocationTicket { + reconciler: self.clone(), + } + } + /// Requests a reconciliation now, without the debounce: sharing was /// turned off or a podcast unsubscribed, and its card must be revoked - /// before the user may quit. See [`Reconciler::flush`]. - pub fn revoke_now(&self) { + /// before the user may quit. `was_shared`: the podcast, when it was + /// shared just before (a card from this device may be live). See + /// [`Reconciler::flush`]. + pub fn revoke_now(&self, was_shared: Option<&PodcastId>) { + if let Some(podcast_id) = was_shared { + self.revoked + .lock() + .unwrap_or_else(PoisonError::into_inner) + .insert(podcast_id.clone()); + } self.revocations.fetch_add(1, Ordering::SeqCst); self.urgent.notify_one(); } - /// Waits, at most `timeout`, until a pass started after every - /// [`Reconciler::revoke_now`] so far finished (the tombstones were - /// signed and pushed, or the overlay is off and nothing can be sent). - /// Returns at once when nothing is pending. `false` on timeout or when + /// Waits, at most `timeout`, until the revocations being written + /// ([`Reconciler::begin_revocation`]) are written and a pass started + /// after every [`Reconciler::revoke_now`] so far finished (the + /// tombstones were signed and pushed, or the overlay is off and nothing + /// can be sent). Returns at once when nothing is pending. `true` when + /// that pass left no card of a private podcast live from this device; + /// `false` when one may be (revocation failed, or the federation is off + /// and cards of an earlier session may be live), on timeout, or when /// the reconciler stopped. pub async fn flush(&self, timeout: Duration) -> bool { - let target = self.revocations.load(Ordering::SeqCst); - let mut covered = self.covered.clone(); - if *covered.borrow() >= target { - return true; - } - // `revoke_now` already asked for the pass. - matches!( - tokio::time::timeout(timeout, covered.wait_for(|covered| *covered >= target)).await, - Ok(Ok(_)) - ) + let wait = async { + let mut in_flight = self.in_flight.subscribe(); + if in_flight + .wait_for(|in_flight| *in_flight == 0) + .await + .is_err() + { + return false; + } + let target = self.revocations.load(Ordering::SeqCst); + let mut covered = self.covered.clone(); + // `revoke_now` already asked for the pass. + match covered + .wait_for(|covered| covered.revocations >= target) + .await + { + Ok(covered) => covered.unrevoked == 0, + Err(_) => false, + } + }; + tokio::time::timeout(timeout, wait).await.unwrap_or(false) } } +/// The podcasts of `unrevoked` that are not shared now (a podcast shared +/// again is no longer "private · not revoked"). Without a store, all. +async fn still_private( + store: Option<&Arc>, + unrevoked: BTreeSet, +) -> BTreeSet { + let Some(store) = store.cloned() else { + return unrevoked; + }; + if unrevoked.is_empty() { + return unrevoked; + } + let fallback = unrevoked.clone(); + tokio::task::spawn_blocking(move || { + unrevoked + .into_iter() + .filter(|podcast_id| { + !matches!(store.podcast(podcast_id), Ok(Some(summary)) if summary.shared) + }) + .collect() + }) + .await + .unwrap_or(fallback) +} + /// 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 (keeping the cards known not to be revoked -/// yet: they are revoked once the overlay runs again). Between passes the -/// overlay's peer count is refreshed every [`PEER_REFRESH_INTERVAL`]. +/// device and `report` says so, keeping as not revoked the cards known not +/// to be revoked yet and those of podcasts that were shared and revoked +/// here meanwhile (`Reconciler::revoke_now`): they are revoked once the +/// overlay runs again. Between passes the overlay's peer count is +/// refreshed every [`PEER_REFRESH_INTERVAL`]. pub fn spawn( mut dht: watch::Receiver>>, store: Option>, @@ -903,11 +1014,14 @@ pub fn spawn( let wake = Arc::new(Notify::new()); let urgent = Arc::new(Notify::new()); let revocations = Arc::new(AtomicU64::new(0)); - let (covered_tx, covered) = watch::channel(0); + let revoked = Arc::new(Mutex::new(BTreeSet::new())); + let (covered_tx, covered) = watch::channel(Covered::default()); let reconciler = Reconciler { wake: Arc::clone(&wake), urgent: Arc::clone(&urgent), revocations: Arc::clone(&revocations), + in_flight: Arc::new(watch::channel(0).0), + revoked: Arc::clone(&revoked), covered, }; tokio::spawn(async move { @@ -916,20 +1030,33 @@ pub fn spawn( peers.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay); peers.reset(); loop { + // Read before the revoked podcasts: `revoke_now` records the + // podcast before it counts the revocation. let requested = revocations.load(Ordering::SeqCst); + let revoked_here = + std::mem::take(&mut *revoked.lock().unwrap_or_else(PoisonError::into_inner)); let current = dht.borrow_and_update().clone(); last = match current { + // The pass sees this device's own publications: it revokes + // and reports exactly what is still live. Some(dht) => reconcile(&dht, store.clone(), Arc::clone(&confirmations)).await, - None => PublicationReport { - discovery: Discovery::Off( - "federation is off or podcast discovery is unavailable".into(), - ), - unrevoked: std::mem::take(&mut last.unrevoked), - ..PublicationReport::default() - }, + None => { + let mut unrevoked = std::mem::take(&mut last.unrevoked); + unrevoked.extend(revoked_here); + PublicationReport { + discovery: Discovery::Off( + "federation is off or podcast discovery is unavailable".into(), + ), + unrevoked: still_private(store.as_ref(), unrevoked).await, + ..PublicationReport::default() + } + } }; report(last.clone()); - covered_tx.send_replace(requested); + covered_tx.send_replace(Covered { + revocations: requested, + unrevoked: last.unrevoked.len(), + }); let periodic = tokio::time::sleep(RECONCILE_INTERVAL); tokio::pin!(periodic); loop { diff --git a/src/podcasts/publication_tests.rs b/src/podcasts/publication_tests.rs index 858ebc6..8bcc502 100644 --- a/src/podcasts/publication_tests.rs +++ b/src/podcasts/publication_tests.rs @@ -616,10 +616,26 @@ fn revocations_that_fail_are_reported_without_ids() { report .podcasts .insert(secret.clone(), Publication::HeldBack(Vec::new())); - report.note_revocation(&show); - report.note_revocation(&secret); + report.discovery = Discovery::Running { peers: 1 }; + report.note_revocation(&show, true); + report.note_revocation(&secret, true); assert!(report.podcasts.is_empty()); - assert_eq!(report.unrevoked, [show].into_iter().collect()); + assert_eq!(report.unrevoked, [show.clone()].into_iter().collect()); + + // Without a pass of the running overlay nothing tells whether a card + // of an earlier session is live: a podcast that was shared counts. + for discovery in [ + Discovery::Off("federation is off".into()), + Discovery::Starting, + ] { + let mut report = PublicationReport { + discovery, + ..PublicationReport::default() + }; + report.note_revocation(&show, true); + report.note_revocation(&diary, false); + assert_eq!(report.unrevoked, [show.clone()].into_iter().collect()); + } } // --------------------------------------------------------------------------- @@ -930,6 +946,43 @@ async fn reconciler_lifecycle() { assert!(report.podcasts.is_empty()); assert!(reconciler.flush(Duration::from_millis(10)).await); + // Sharing off while the federation is off (a card of an earlier + // session may be live). Quitting while the decision is still being + // written waits for the write and the pass, then says the card may not + // be revoked; the Off reports keep it as not revoked. + let ticket = reconciler.begin_revocation(); + assert!( + !reconciler.flush(Duration::from_millis(50)).await, + "the write is still running" + ); + let flush = tokio::spawn({ + let reconciler = reconciler.clone(); + async move { reconciler.flush(Duration::from_secs(5)).await } + }); + tokio::time::sleep(Duration::from_millis(100)).await; + assert!(!flush.is_finished(), "quitting waits for the write"); + device.set_shared(&store, &show, false); + ticket.done(Some(&show)); + assert!(!flush.await.unwrap(), "the card may not be revoked yet"); + let report = next().await; + assert!(matches!(report.discovery, Discovery::Off(_))); + assert_eq!(report.unrevoked, [show.clone()].into_iter().collect()); + reconciler.wake(); + let report = next().await; + assert_eq!( + report.unrevoked, + [show.clone()].into_iter().collect(), + "kept while the federation is off" + ); + // A write that failed (the ticket is dropped) is not waited for. + drop(reconciler.begin_revocation()); + // Shared again: no longer "private · not revoked". + device.set_shared(&store, &show, true); + reconciler.wake(); + let report = next().await; + assert!(report.unrevoked.is_empty()); + assert!(reconciler.flush(Duration::from_millis(10)).await); + // The overlay starts (two nodes, the overlay not bootstrapped yet): a // pass publishes right away. let a = Node::start(&temp.path().join("a"), network).await; @@ -977,7 +1030,7 @@ async fn reconciler_lifecycle() { // Sharing off: the revocation does not wait for the debounce, and the // quit-time flush returns once the tombstone was sent. device.set_shared(&store, &show, false); - reconciler.revoke_now(); + reconciler.revoke_now(Some(&show)); assert!( reconciler.flush(RECONCILE_DEBOUNCE * 9 / 10).await, "revoked before the debounce would have ended" diff --git a/src/ui/mod.rs b/src/ui/mod.rs index 7e1bba3..9df781d 100644 --- a/src/ui/mod.rs +++ b/src/ui/mod.rs @@ -228,7 +228,7 @@ mod tests { state .podcasts .publication - .note_revocation(&podcast_fixtures::podcast_id()); + .note_revocation(&podcast_fixtures::podcast_id(), true); let screen = render(&state, 110, 30); assert!(screen.contains("private · revoking the"), "{screen}"); if let Some(crate::app::state::Loadable::Ready(rows)) = &mut state.podcasts.list { @@ -239,7 +239,8 @@ mod tests { assert!(!screen.contains("private (not shared"), "{screen}"); state.podcasts.publication.discovery = Discovery::Off("federation is off".into()); let screen = render(&state, 110, 30); - assert!(screen.contains("not revoked yet:"), "{screen}"); + assert!(screen.contains("may not be revoked yet:"), "{screen}"); + assert!(screen.contains("federation is off"), "{screen}"); state.podcasts.publication.unrevoked.clear(); let screen = render(&state, 110, 30); assert!(screen.contains("private (not shared"), "{screen}"); diff --git a/src/ui/podcasts.rs b/src/ui/podcasts.rs index bff6f6f..b51b852 100644 --- a/src/ui/podcasts.rs +++ b/src/ui/podcasts.rs @@ -323,7 +323,7 @@ pub(crate) fn share_status_line(state: &AppState, podcast: &PodcastRow) -> Line< } if let Discovery::Off(_) = report.discovery { return Line::styled( - "private · public card not revoked yet: federation is off", + "private · public card may not be revoked yet: federation is off", Style::new().fg(Color::Yellow), ); }