Keep a published card's representative across restarts

The account that provides a published card stays its representative
ahead of server-fetched metadata, and after a restart it is recognized
by the text of the active card. Server-fetched metadata only counts as
trusted when the catalog URL is the podcast's origin, since an account
can point its synced catalog URL anywhere.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
sanapachandClaude Opus 5.5 committed 2026-11-20 15:12:52 +02:00
1 parent 767134d1dd
commit bbdac75967
3 files changed
+140 -26

No files matched your search

+125 -19
View File
@@ -66,8 +66,8 @@ use std::time::Duration;
use anyhow::Result;
use music_dht::podcast::{FeedUrl, PodcastId, PodcastMeta, ShareRecord, SubscriptionRecord};
use music_dht::podcast_dht::{
FeedUrlPrivacyWarning, MAX_PODCAST_RECORDS_PER_PUBLISHER, PodcastCardSpec, PodcastDht,
PodcastDhtSyncStats, PodcastShareState, PublishedPodcast,
FeedUrlPrivacyWarning, MAX_PODCAST_RECORDS_PER_PUBLISHER, PodcastCard, PodcastCardSpec,
PodcastDht, PodcastDhtSyncStats, PodcastShareState, PublishedPodcast,
};
use sqlx::{PgConnection, PgPool, Row};
use tokio::sync::Notify;
@@ -201,6 +201,19 @@ impl AccountShare {
&& !self.privacy_confirmed()
}
/// Whether the catalog text comes from the server's own fetch of the
/// podcast's origin URL (the URL its id is derived from): an account
/// can point its synced catalog at any URL before the server fetches
/// it, so `meta_from_feed` alone says nothing about where the text
/// comes from.
pub(crate) fn trusted_meta(&self) -> bool {
self.meta_from_feed
&& self.card.as_ref().is_ok_and(|card| {
card.id_feed_url.is_none()
&& PodcastId::from_feed_url(&card.feed_url) == self.subscription.podcast_id
})
}
/// Whether the account counts as sharing the podcast publicly.
pub(crate) fn publishable(&self) -> bool {
self.is_shared()
@@ -440,13 +453,16 @@ pub(crate) struct Aggregation {
pub(crate) struct Incumbents {
/// Podcasts with an active card of this node (`PodcastDht::published`).
pub(crate) published: BTreeSet<PodcastId>,
/// Public text of every active card, so its representative is
/// recognized after a restart too ([`CardText`]).
pub(crate) cards: BTreeMap<PodcastId, CardText>,
/// Podcasts of which replicas still hold a record of this node: active
/// cards and tombstones that have not expired. Each one occupies a
/// `(podcast_id, publisher)` key in the replicas; republishing it
/// reuses the key.
pub(crate) live_keys: BTreeSet<PodcastId>,
/// Representative account of each card in the previous round (kept in
/// memory; empty after a restart).
/// memory; empty after a restart, then [`Self::cards`] decides).
pub(crate) representatives: BTreeMap<PodcastId, i64>,
}
@@ -457,6 +473,11 @@ impl Incumbents {
for publication in publications {
if publication.active {
incumbents.published.insert(publication.podcast_id.clone());
if let Some(card) = publication.record.card() {
incumbents
.cards
.insert(publication.podcast_id.clone(), CardText::of_card(card));
}
}
if publication.active || publication.record.expires_at_ms() > now_ms {
incumbents.live_keys.insert(publication.podcast_id.clone());
@@ -482,6 +503,44 @@ impl Incumbents {
}
}
/// The public text of a card: what a representative decides.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct CardText {
feed_url: FeedUrl,
id_feed_url: Option<FeedUrl>,
title: String,
author: Option<String>,
description: Option<String>,
image_url: Option<String>,
link: Option<String>,
}
impl CardText {
fn of_spec(spec: &PodcastCardSpec) -> Self {
Self {
feed_url: spec.feed_url.clone(),
id_feed_url: spec.id_feed_url.clone(),
title: spec.title.clone(),
author: spec.author.clone(),
description: spec.description.clone(),
image_url: spec.image_url.clone(),
link: spec.link.clone(),
}
}
fn of_card(card: &PodcastCard) -> Self {
Self {
feed_url: card.feed_url.clone(),
id_feed_url: card.id_feed_url.clone(),
title: card.title.clone(),
author: card.author.clone(),
description: card.description.clone(),
image_url: card.image_url.clone(),
link: card.link.clone(),
}
}
}
/// Computes what the server node publishes from the accounts' views.
///
/// * Only accounts for which [`AccountShare::publishable`] holds count.
@@ -490,11 +549,12 @@ impl Incumbents {
/// warnings, or the account confirmed exactly these URLs for its current
/// share decision), so `sync_shares` never holds anything back on its
/// own. The representative is, in this order: an account whose card has
/// no privacy warnings; an account whose catalog comes from the server's
/// own fetch of the feed (`meta_from_feed`), not from metadata a client
/// synced; the previous round's representative, so another account
/// sharing the same podcast does not take over a published card; the
/// smallest account id.
/// no privacy warnings; the *incumbent* (the previous round's
/// representative, or after a restart an account whose card has the
/// exact text of the published card), so another account sharing the
/// same podcast never takes over a published card; an account whose
/// catalog the server fetched itself from the podcast's origin URL
/// ([`AccountShare::trusted_meta`]); the smallest account id.
/// * At most [`MAX_SERVER_SHARED_PODCASTS`] podcasts, shared fairly between
/// the accounts ([`allocate`]): an account whose podcasts fit in its fair
/// part of the budget never loses a published card because of other
@@ -521,15 +581,23 @@ pub(crate) fn aggregate_share_states(
let mut queues: BTreeMap<i64, Vec<QueuedPodcast>> = BTreeMap::new();
for (podcast_id, accounts) in by_podcast {
let previous = incumbents.representatives.get(&podcast_id).copied();
let published_text = incumbents.cards.get(&podcast_id);
let publishable: Vec<&AccountShare> = accounts
.iter()
.filter(|share| share.publishable())
.collect();
let representative = publishable.iter().min_by_key(|share| {
let same_text = published_text.is_some_and(|published| {
share
.card
.as_ref()
.is_ok_and(|card| CardText::of_spec(card) == *published)
});
(
!share.warnings().is_empty(),
!share.meta_from_feed,
previous != Some(share.user_id),
!same_text,
!share.trusted_meta(),
share.user_id,
)
});
@@ -1191,12 +1259,13 @@ mod tests {
}
#[test]
fn a_published_card_keeps_its_representative_and_server_fetched_metadata() {
fn a_published_card_keeps_its_representative() {
// Account 9 provides the published card; account 3 starts sharing
// the same podcast with its own (synced) metadata.
// the same podcast with other text.
let provider = account(9, "a.xml", true, 10);
let mut newcomer = account(3, "a.xml", true, 20);
newcomer.card.as_mut().unwrap().title = "Rewritten".into();
let published_card = CardText::of_spec(provider.card.as_ref().unwrap());
let incumbents = Incumbents {
published: BTreeSet::from([id("a.xml")]),
representatives: BTreeMap::from([(id("a.xml"), 9)]),
@@ -1210,16 +1279,53 @@ mod tests {
"Show a.xml"
);
// Metadata only a client synced loses to the server's own fetch,
// even for a smaller account id or the previous representative.
newcomer.meta_from_feed = false;
let aggregation = aggregate(vec![provider.clone(), newcomer.clone()]);
// After a restart (no memory) the published card's text names it.
let restarted = Incumbents {
published: BTreeSet::from([id("a.xml")]),
cards: BTreeMap::from([(id("a.xml"), published_card)]),
..Incumbents::default()
};
let aggregation =
aggregate_share_states(vec![provider.clone(), newcomer.clone()], &restarted);
assert_eq!(aggregation.representatives[&id("a.xml")], 9);
let mut synced_provider = provider;
// The incumbent also outranks server-fetched metadata of another
// account: whoever shares first keeps the card's text.
let mut synced_provider = provider.clone();
synced_provider.meta_from_feed = false;
newcomer.meta_from_feed = true;
let aggregation = aggregate_share_states(vec![synced_provider, newcomer], &incumbents);
assert_eq!(aggregation.representatives[&id("a.xml")], 3);
let aggregation =
aggregate_share_states(vec![synced_provider, newcomer.clone()], &incumbents);
assert_eq!(aggregation.representatives[&id("a.xml")], 9);
// Without an incumbent, metadata the server fetched from the origin
// URL wins over metadata a client synced, even for a smaller id.
newcomer.meta_from_feed = false;
let aggregation = aggregate(vec![provider, newcomer]);
assert_eq!(aggregation.representatives[&id("a.xml")], 9);
}
#[test]
fn metadata_fetched_from_another_url_is_not_trusted() {
// Account 3 synced a catalog URL of its choice (the origin stays
// in its aliases); the server fetched that URL, so `meta_from_feed`
// holds, but the text does not come from the podcast's origin.
let mut pointed = account(3, "a.xml", true, 10);
pointed.card = build_card(
&pointed.subscription,
Some(&PodcastMeta {
feed_url: url("elsewhere.xml"),
title: "Elsewhere".into(),
..pointed.subscription.podcast.clone()
}),
None,
None,
);
assert!(pointed.meta_from_feed);
assert!(!pointed.trusted_meta());
let origin = account(9, "a.xml", true, 20);
assert!(origin.trusted_meta());
let aggregation = aggregate(vec![pointed, origin]);
assert_eq!(aggregation.representatives[&id("a.xml")], 9);
}
#[test]