From c0018047c7fe4e2a88c4a9a9d194f955deda3cfc Mon Sep 17 00:00:00 2001 From: kenny lopez Date: Thu, 20 Aug 2026 10:31:57 +0100 Subject: [PATCH] Make DM visibility reconciliation durable Signed-off-by: kenny lopez --- crates/buzz-db/src/deletion.rs | 2 + crates/buzz-db/src/dm.rs | 184 +++++++++++-- crates/buzz-db/src/lib.rs | 257 +++++++++++------- crates/buzz-db/src/migration.rs | 21 ++ .../src/handlers/moderation_notices.rs | 217 ++++++++++++++- .../buzz-relay/src/handlers/side_effects.rs | 78 +++--- crates/buzz-relay/src/main.rs | 14 +- .../0032_dm_visibility_dirty_viewers.sql | 32 +++ schema/schema.sql | 28 ++ 9 files changed, 641 insertions(+), 192 deletions(-) create mode 100644 migrations/0032_dm_visibility_dirty_viewers.sql diff --git a/crates/buzz-db/src/deletion.rs b/crates/buzz-db/src/deletion.rs index fbe69f22a6..239f3e2ebe 100644 --- a/crates/buzz-db/src/deletion.rs +++ b/crates/buzz-db/src/deletion.rs @@ -61,6 +61,7 @@ pub const EXPECTED_SCOPED_TABLES: &[&str] = &[ "channels", "community_bans", "delivery_log", + "dm_visibility_dirty_viewers", "event_mentions", "events", "git_repo_names", @@ -90,6 +91,7 @@ pub const PURGE_SCOPED_TABLES: &[&str] = &[ "scheduled_workflow_fires", "workflow_runs", "push_wake_outbox", + "dm_visibility_dirty_viewers", "join_policy_acceptances", "moderation_reports", "subscriptions", diff --git a/crates/buzz-db/src/dm.rs b/crates/buzz-db/src/dm.rs index 9f5baa1b85..b106d2cd1e 100644 --- a/crates/buzz-db/src/dm.rs +++ b/crates/buzz-db/src/dm.rs @@ -38,6 +38,20 @@ pub struct DmParticipant { pub role: String, } +/// One bounded retry-queue claim for a relay-authored DM visibility snapshot. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ClaimedDmVisibilityViewer { + /// Community containing the viewer's DM memberships. + pub community_id: CommunityId, + /// Canonical host used to construct the tenant context for fan-out. + pub community_host: String, + /// Viewer whose kind:30622 projection needs rebuilding. + pub viewer: Vec, + /// Claim fence used to release a failed publication without touching a + /// newer mutation that reset the queue row. + pub claim_id: Uuid, +} + // -- Pure helpers ------------------------------------------------------------- /// Compute a stable SHA-256 fingerprint for a set of participant pubkeys. @@ -402,9 +416,25 @@ pub async fn hide_dm( ) -> Result<()> { let result = sqlx::query( r#" - UPDATE channel_members - SET hidden_at = NOW() - WHERE community_id = $1 AND channel_id = $2 AND pubkey = $3 AND removed_at IS NULL + WITH changed AS ( + UPDATE channel_members + SET hidden_at = NOW() + WHERE community_id = $1 + AND channel_id = $2 + AND pubkey = $3 + AND removed_at IS NULL + RETURNING pubkey + ) + INSERT INTO dm_visibility_dirty_viewers (community_id, viewer) + SELECT $1, pubkey FROM changed + ON CONFLICT (community_id, viewer) DO UPDATE SET + generation = dm_visibility_dirty_viewers.generation + 1, + state = 'pending', + dirty_at = NOW(), + next_attempt_at = NOW(), + claim_id = NULL, + lease_until = NULL, + attempts = 0 "#, ) .bind(community_id.as_uuid()) @@ -434,9 +464,25 @@ pub async fn unhide_dm( ) -> Result<()> { sqlx::query( r#" - UPDATE channel_members - SET hidden_at = NULL - WHERE community_id = $1 AND channel_id = $2 AND pubkey = $3 AND removed_at IS NULL + WITH changed AS ( + UPDATE channel_members + SET hidden_at = NULL + WHERE community_id = $1 + AND channel_id = $2 + AND pubkey = $3 + AND removed_at IS NULL + RETURNING pubkey + ) + INSERT INTO dm_visibility_dirty_viewers (community_id, viewer) + SELECT $1, pubkey FROM changed + ON CONFLICT (community_id, viewer) DO UPDATE SET + generation = dm_visibility_dirty_viewers.generation + 1, + state = 'pending', + dirty_at = NOW(), + next_attempt_at = NOW(), + claim_id = NULL, + lease_until = NULL, + attempts = 0 "#, ) .bind(community_id.as_uuid()) @@ -462,19 +508,32 @@ pub async fn unhide_dm_recipients( ) -> Result>> { let rows = sqlx::query( r#" - UPDATE channel_members cm - SET hidden_at = NULL - FROM channels c - WHERE cm.community_id = $1 - AND cm.channel_id = $2 - AND cm.pubkey != $3 - AND cm.removed_at IS NULL - AND cm.hidden_at IS NOT NULL - AND c.community_id = cm.community_id - AND c.id = cm.channel_id - AND c.channel_type = 'dm' - AND c.deleted_at IS NULL - RETURNING cm.pubkey + WITH changed AS ( + UPDATE channel_members cm + SET hidden_at = NULL + FROM channels c + WHERE cm.community_id = $1 + AND cm.channel_id = $2 + AND cm.pubkey != $3 + AND cm.removed_at IS NULL + AND cm.hidden_at IS NOT NULL + AND c.community_id = cm.community_id + AND c.id = cm.channel_id + AND c.channel_type = 'dm' + AND c.deleted_at IS NULL + RETURNING cm.pubkey + ) + INSERT INTO dm_visibility_dirty_viewers (community_id, viewer) + SELECT $1, pubkey FROM changed + ON CONFLICT (community_id, viewer) DO UPDATE SET + generation = dm_visibility_dirty_viewers.generation + 1, + state = 'pending', + dirty_at = NOW(), + next_attempt_at = NOW(), + claim_id = NULL, + lease_until = NULL, + attempts = 0 + RETURNING viewer "#, ) .bind(community_id.as_uuid()) @@ -484,10 +543,95 @@ pub async fn unhide_dm_recipients( .await?; rows.into_iter() - .map(|row| row.try_get::, _>("pubkey").map_err(Into::into)) + .map(|row| row.try_get::, _>("viewer").map_err(Into::into)) .collect() } +/// Claim at most `limit` indexed dirty-viewer rows across active communities. +/// Expired claims are recovered by the same bounded query. +pub async fn claim_dm_visibility_dirty_viewers( + pool: &PgPool, + limit: i64, + lease_seconds: i64, +) -> Result> { + let claim_id = Uuid::new_v4(); + let rows = sqlx::query( + r#" + WITH candidates AS ( + SELECT q.community_id, q.viewer + FROM dm_visibility_dirty_viewers q + JOIN communities c ON c.id = q.community_id + WHERE c.archived_at IS NULL + AND c.deleted_at IS NULL + AND c.deletion_state = 'active' + AND community_write_allowed(q.community_id) + AND ( + (q.state = 'pending' AND q.next_attempt_at <= NOW()) + OR (q.state = 'publishing' AND q.lease_until <= NOW()) + ) + ORDER BY COALESCE(q.lease_until, q.next_attempt_at), q.dirty_at + FOR UPDATE OF q SKIP LOCKED + LIMIT $1 + ) + UPDATE dm_visibility_dirty_viewers q + SET state = 'publishing', + claim_id = $2, + lease_until = NOW() + make_interval(secs => $3::int), + attempts = q.attempts + 1 + FROM candidates candidate, communities c + WHERE q.community_id = candidate.community_id + AND q.viewer = candidate.viewer + AND c.id = q.community_id + RETURNING q.community_id, c.host, q.viewer + "#, + ) + .bind(limit.clamp(1, 1_000)) + .bind(claim_id) + .bind(lease_seconds.clamp(1, 3_600) as i32) + .fetch_all(pool) + .await?; + + rows.into_iter() + .map(|row| { + Ok(ClaimedDmVisibilityViewer { + community_id: CommunityId::from_uuid(row.try_get("community_id")?), + community_host: row.try_get("host")?, + viewer: row.try_get("viewer")?, + claim_id, + }) + }) + .collect() +} + +/// Release a failed queue claim for a bounded retry. A mutation that occurred +/// after the claim resets `claim_id`, so this cannot overwrite newer work. +pub async fn retry_dm_visibility_dirty_viewer( + pool: &PgPool, + community_id: CommunityId, + viewer: &[u8], + claim_id: Uuid, +) -> Result<()> { + sqlx::query( + r#" + UPDATE dm_visibility_dirty_viewers + SET state = 'pending', + next_attempt_at = NOW() + INTERVAL '5 seconds', + claim_id = NULL, + lease_until = NULL + WHERE community_id = $1 + AND viewer = $2 + AND state = 'publishing' + AND claim_id = $3 + "#, + ) + .bind(community_id.as_uuid()) + .bind(viewer) + .bind(claim_id) + .execute(pool) + .await?; + Ok(()) +} + /// Return the channel IDs of all DMs the given user currently has hidden /// (`hidden_at IS NOT NULL`) while still being an active member. Used to build /// the relay-signed NIP-DV visibility snapshot. diff --git a/crates/buzz-db/src/lib.rs b/crates/buzz-db/src/lib.rs index e2d03237e1..757c5502e7 100644 --- a/crates/buzz-db/src/lib.rs +++ b/crates/buzz-db/src/lib.rs @@ -2921,88 +2921,25 @@ impl Db { dm::list_hidden_dms(&self.pool, community_id, pubkey).await } - /// Return viewers whose relay-authored DM visibility snapshot is absent or - /// differs from the canonical `channel_members.hidden_at` rows. - /// - /// A missing snapshot only needs repair when the viewer currently hides at - /// least one DM. An absent snapshot and an explicit empty snapshot are - /// equivalent for viewers with no hidden DMs. - #[datastore_span( - name = "dm_visibility_viewers_needing_reconciliation", - system = "postgresql" - )] - pub async fn dm_visibility_viewers_needing_reconciliation( + /// Claim a bounded batch from the durable DM visibility retry queue. + #[datastore_span(name = "claim_dm_visibility_dirty_viewers", system = "postgresql")] + pub async fn claim_dm_visibility_dirty_viewers( + &self, + limit: i64, + lease_seconds: i64, + ) -> Result> { + dm::claim_dm_visibility_dirty_viewers(&self.pool, limit, lease_seconds).await + } + + /// Release a failed DM visibility claim without overwriting newer work. + #[datastore_span(name = "retry_dm_visibility_dirty_viewer", system = "postgresql")] + pub async fn retry_dm_visibility_dirty_viewer( &self, community_id: CommunityId, - relay_pubkey: &nostr::PublicKey, - limit: i64, - ) -> Result>> { - let rows = sqlx::query( - r#" - WITH canonical AS ( - SELECT - cm.pubkey, - COALESCE( - array_agg(cm.channel_id::text ORDER BY cm.channel_id::text) - FILTER (WHERE cm.hidden_at IS NOT NULL), - ARRAY[]::text[] - ) AS hidden_channels - FROM channel_members cm - JOIN channels c - ON c.community_id = cm.community_id - AND c.id = cm.channel_id - WHERE cm.community_id = $1 - AND cm.removed_at IS NULL - AND c.channel_type = 'dm' - AND c.deleted_at IS NULL - GROUP BY cm.pubkey - ), - snapshots AS ( - SELECT - e.d_tag, - COALESCE( - array_agg(tag.value->>1 ORDER BY tag.value->>1) - FILTER ( - WHERE jsonb_typeof(tag.value) = 'array' - AND jsonb_array_length(tag.value) >= 2 - AND tag.value->>0 = 'h' - ), - ARRAY[]::text[] - ) AS hidden_channels - FROM events e - LEFT JOIN LATERAL jsonb_array_elements(e.tags) AS tag(value) ON TRUE - WHERE e.community_id = $1 - AND e.kind = $2 - AND e.pubkey = $3 - AND e.channel_id IS NULL - AND e.deleted_at IS NULL - AND e.d_tag IS NOT NULL - GROUP BY e.d_tag - ) - SELECT canonical.pubkey - FROM canonical - LEFT JOIN snapshots - ON snapshots.d_tag = encode(canonical.pubkey, 'hex') - WHERE - (snapshots.d_tag IS NULL AND cardinality(canonical.hidden_channels) > 0) - OR ( - snapshots.d_tag IS NOT NULL - AND snapshots.hidden_channels IS DISTINCT FROM canonical.hidden_channels - ) - ORDER BY canonical.pubkey - LIMIT $4 - "#, - ) - .bind(community_id.as_uuid()) - .bind(buzz_core::kind::KIND_DM_VISIBILITY as i32) - .bind(relay_pubkey.to_bytes().as_slice()) - .bind(limit.max(1)) - .fetch_all(&self.pool) - .await?; - - rows.into_iter() - .map(|row| row.try_get::, _>("pubkey").map_err(Into::into)) - .collect() + viewer: &[u8], + claim_id: Uuid, + ) -> Result<()> { + dm::retry_dm_visibility_dirty_viewer(&self.pool, community_id, viewer, claim_id).await } /// Atomically rebuild one viewer's relay-authored DM visibility snapshot. @@ -3043,7 +2980,7 @@ impl Db { let lock_key = event_replacement_lock_key( community_id, kind_i32, - relay_pubkey_bytes.as_slice(), + b"dm-visibility-viewer", Some(viewer_hex.as_bytes()), ); @@ -3053,6 +2990,15 @@ impl Db { .execute(&mut *tx) .await?; + let dirty_generation: Option = sqlx::query_scalar( + "SELECT generation FROM dm_visibility_dirty_viewers \ + WHERE community_id = $1 AND viewer = $2", + ) + .bind(community_id.as_uuid()) + .bind(viewer) + .fetch_optional(&mut *tx) + .await?; + let hidden = sqlx::query_scalar::<_, Uuid>( r#" SELECT cm.channel_id @@ -3074,17 +3020,18 @@ impl Db { .fetch_all(&mut *tx) .await?; + // The viewer coordinate is authoritative across relay-key rotation. + // Advance past every prior author so an old-key future-dated head can + // never beat the first snapshot signed by the replacement key. let previous_created_at: Option> = sqlx::query_scalar( - "SELECT created_at FROM events \ - WHERE community_id = $1 AND kind = $2 AND pubkey = $3 \ - AND d_tag = $4 AND channel_id IS NULL AND deleted_at IS NULL \ - ORDER BY created_at DESC, id ASC LIMIT 1", + "SELECT MAX(created_at) FROM events \ + WHERE community_id = $1 AND kind = $2 \ + AND d_tag = $3 AND channel_id IS NULL AND deleted_at IS NULL", ) .bind(community_id.as_uuid()) .bind(kind_i32) - .bind(relay_pubkey_bytes.as_slice()) .bind(&viewer_hex) - .fetch_optional(&mut *tx) + .fetch_one(&mut *tx) .await?; let mut tags = Vec::with_capacity(hidden.len() + 2); @@ -3101,9 +3048,17 @@ impl Db { } let now = nostr::Timestamp::now().as_secs(); - let created_at = previous_created_at - .map(|timestamp| (timestamp.timestamp() as u64 + 1).max(now)) - .unwrap_or(now); + let created_at = match previous_created_at { + Some(timestamp) => { + let previous = u64::try_from(timestamp.timestamp()) + .map_err(|_| DbError::InvalidData("negative DM visibility timestamp".into()))?; + previous + .checked_add(1) + .ok_or(DbError::InvalidTimestamp(timestamp.timestamp()))? + .max(now) + } + None => now, + }; let event = EventBuilder::new(Kind::Custom(kind_i32 as u16), "") .tags(tags) .custom_created_at(nostr::Timestamp::from(created_at)) @@ -3119,12 +3074,11 @@ impl Db { sqlx::query( "UPDATE events SET deleted_at = NOW() \ - WHERE community_id = $1 AND kind = $2 AND pubkey = $3 \ - AND d_tag = $4 AND channel_id IS NULL AND deleted_at IS NULL", + WHERE community_id = $1 AND kind = $2 \ + AND d_tag = $3 AND channel_id IS NULL AND deleted_at IS NULL", ) .bind(community_id.as_uuid()) .bind(kind_i32) - .bind(relay_pubkey_bytes.as_slice()) .bind(&viewer_hex) .execute(&mut *tx) .await?; @@ -3153,6 +3107,17 @@ impl Db { .await?; insert_mentions_in_transaction(&mut tx, community_id, &event, None).await?; + if let Some(generation) = dirty_generation { + sqlx::query( + "DELETE FROM dm_visibility_dirty_viewers \ + WHERE community_id = $1 AND viewer = $2 AND generation = $3", + ) + .bind(community_id.as_uuid()) + .bind(viewer) + .bind(generation) + .execute(&mut *tx) + .await?; + } tx.commit().await?; Ok(( @@ -7600,12 +7565,13 @@ mod tests { .is_err(), "injected event failure must fail publication after canonical mutation" ); - assert_eq!( - db.dm_visibility_viewers_needing_reconciliation(community, &relay.public_key(), 100,) - .await - .expect("scan drift after failure"), - vec![viewer_bytes.to_vec()] - ); + let claimed = db + .claim_dm_visibility_dirty_viewers(100, 60) + .await + .expect("claim dirty viewer after failure"); + assert_eq!(claimed.len(), 1); + assert_eq!(claimed[0].community_id, community); + assert_eq!(claimed[0].viewer, viewer_bytes.to_vec()); sqlx::query("DROP TRIGGER reject_dm_visibility_event ON events") .execute(&pool) @@ -7615,11 +7581,11 @@ mod tests { .await .expect("reconcile visibility snapshot"); assert!( - db.dm_visibility_viewers_needing_reconciliation(community, &relay.public_key(), 100,) + db.claim_dm_visibility_dirty_viewers(100, 60) .await - .expect("scan after reconciliation") + .expect("claim after reconciliation") .is_empty(), - "repaired snapshot must match canonical state" + "successful publication must remove its durable dirty marker" ); let snapshot = db .query_events(&EventQuery { @@ -7777,6 +7743,93 @@ mod tests { drop_scratch_db(&admin, pool, &scratch_name).await; } + #[tokio::test] + #[ignore = "requires Postgres"] + async fn dm_visibility_key_rotation_supersedes_future_dated_old_key_snapshot() { + use nostr::{EventBuilder, Keys, Kind, Tag}; + + let admin = PgPool::connect(&admin_url().await) + .await + .expect("connect admin"); + let (pool, scratch_name) = create_scratch_db(&admin, "dm_visibility_rotation").await; + let db = Db::from_pool(pool.clone()); + let community_uuid = Uuid::new_v4(); + sqlx::query("INSERT INTO communities (id, host) VALUES ($1, $2)") + .bind(community_uuid) + .bind(format!("dm-visibility-{}.example", community_uuid.simple())) + .execute(&pool) + .await + .expect("insert community"); + let community = CommunityId::from_uuid(community_uuid); + let old_relay = Keys::generate(); + let new_relay = Keys::generate(); + let viewer = Keys::generate(); + let sender = Keys::generate(); + let viewer_bytes = viewer.public_key().to_bytes(); + let sender_bytes = sender.public_key().to_bytes(); + let viewer_hex = viewer.public_key().to_hex(); + let dm = db + .create_dm( + community, + &[viewer_bytes.as_slice(), sender_bytes.as_slice()], + sender_bytes.as_slice(), + ) + .await + .expect("create DM"); + + db.hide_dm(community, dm.id, viewer_bytes.as_slice()) + .await + .expect("hide DM"); + let future_timestamp = nostr::Timestamp::now().as_secs() + 3_600; + let old_head = + EventBuilder::new(Kind::Custom(buzz_core::kind::KIND_DM_VISIBILITY as u16), "") + .tags(vec![ + Tag::parse(["d", &viewer_hex]).expect("d tag"), + Tag::parse(["p", &viewer_hex]).expect("p tag"), + Tag::parse(["h", &dm.id.to_string()]).expect("h tag"), + ]) + .custom_created_at(nostr::Timestamp::from(future_timestamp)) + .sign_with_keys(&old_relay) + .expect("sign old-key snapshot"); + db.replace_parameterized_event(community, &old_head, &viewer_hex, None) + .await + .expect("store old-key snapshot"); + + db.unhide_dm(community, dm.id, viewer_bytes.as_slice()) + .await + .expect("unhide under new relay key"); + let (new_head, _) = db + .publish_dm_visibility_locked(community, viewer_bytes.as_slice(), &new_relay) + .await + .expect("publish first new-key snapshot"); + + assert!( + new_head.event.created_at.as_secs() > future_timestamp, + "new relay key must advance past every prior author at this viewer coordinate" + ); + assert!( + new_head + .event + .tags + .iter() + .all(|tag| tag.as_slice().first().map(String::as_str) != Some("h")), + "new-key repair must project canonical unhidden state" + ); + let old_live = db + .query_events(&EventQuery { + kinds: Some(vec![buzz_core::kind::KIND_DM_VISIBILITY as i32]), + pubkey: Some(old_relay.public_key().to_bytes().to_vec()), + d_tag: Some(viewer_hex), + limit: Some(1), + ..EventQuery::for_community(community) + }) + .await + .expect("query old-key head"); + assert!(old_live.is_empty(), "old-key head must be retired"); + + drop_scratch_db(&admin, pool, &scratch_name).await; + } + // ---- Read-replica routing ------------------------------------------------ // // These tests pin the routing contract of `Db::read()` and the two routed diff --git a/crates/buzz-db/src/migration.rs b/crates/buzz-db/src/migration.rs index 94c7aea2fa..c7cbf13680 100644 --- a/crates/buzz-db/src/migration.rs +++ b/crates/buzz-db/src/migration.rs @@ -1104,6 +1104,24 @@ mod tests { assert!(include_str!("../../../schema/schema.sql").contains("error_code TEXT")); } + #[test] + fn dm_visibility_dirty_viewers_is_a_bounded_community_scoped_queue() { + let migration = MIGRATOR + .iter() + .find(|migration| migration.version == 32) + .expect("DM visibility queue migration"); + let sql = migration.sql.as_str(); + assert!(sql.contains("CREATE TABLE dm_visibility_dirty_viewers")); + assert!(sql.contains("PRIMARY KEY (community_id, viewer)")); + assert!(sql.contains("dm_visibility_dirty_viewers_due")); + assert!(sql.contains("WHERE state = 'pending'")); + assert!(sql.contains("attach_community_write_fence('dm_visibility_dirty_viewers')")); + + let desired_schema = include_str!("../../../schema/schema.sql"); + assert!(desired_schema.contains("CREATE TABLE dm_visibility_dirty_viewers")); + assert!(desired_schema.contains("dm_visibility_dirty_viewers_recovery")); + } + #[test] fn migration_lint_detects_tables_missing_community_id_by_default() { let sql = r#" @@ -1542,6 +1560,9 @@ mod tests { let mut expected_fences = migration.fence_attachments.clone(); expected_fences.remove("product_feedback"); expected_fences.remove("rate_limit_violations"); + // Added after the deletion control plane; migration 0032 attaches the + // same universal write fence when upgrading an existing database. + expected_fences.insert("dm_visibility_dirty_viewers".into()); assert_eq!( expected_fences, schema.fence_attachments, "write-fence attachment targets differ after recovery policy" diff --git a/crates/buzz-relay/src/handlers/moderation_notices.rs b/crates/buzz-relay/src/handlers/moderation_notices.rs index 33b445793f..11af521820 100644 --- a/crates/buzz-relay/src/handlers/moderation_notices.rs +++ b/crates/buzz-relay/src/handlers/moderation_notices.rs @@ -94,6 +94,30 @@ pub async fn send_moderation_notice( return Ok(()); } + // A crash retry for an already-delivered source must be a complete no-op, + // including preserving a later user hide. `open_dm` deliberately unhides + // an existing thread, so perform this check before calling it. + let source_id = notice.source_id(); + let participant_hash = + buzz_db::dm::compute_participant_hash(&[recipient_pubkey, relay_pubkey_bytes.as_slice()]); + if let Some(existing_dm) = state + .db + .find_dm_by_participants(tenant.community(), &participant_hash) + .await? + { + if notice_already_sent( + state, + tenant, + existing_dm.id, + &relay_pubkey_bytes, + source_id, + ) + .await? + { + return Ok(()); + } + } + // 1. Create/reuse the two-party DM channel {relay mod key, recipient}. // `open_dm` is participant-hash idempotent, so re-delivery to the same // user reuses the one thread per (community, user). @@ -130,20 +154,6 @@ pub async fn send_moderation_notice( warn!(error = %e, "moderation DM visibility snapshot failed (continuing)"); } - // Idempotency: a notice for this source id already exists in this DM ⇒ no-op. - // The source (report/action) row id is carried in a `moderation_source` tag - // (NOT `e` — `e` is reserved for 32-byte event ids; this is an opaque row - // UUID). Keyed on it, a retry after a crash between insert and fan-out is a - // safe no-op. Note: this is query-then-insert, so it is crash-retry safe but - // not concurrency-safe — two simultaneous deliveries for the same source can - // both miss the pre-query. Callers invoke this once per action from - // already-serialized side-effect paths; hard per-source serialization is a - // noted follow-up, not done here. - let source_id = notice.source_id(); - if notice_already_sent(state, tenant, dm_channel_id, &relay_pubkey_bytes, source_id).await? { - return Ok(()); - } - // 2. Ensure the relay's "{host} Moderation" kind:0 profile exists, and 3. // the DM's kind:39000 discovery (with `hidden` / `t=dm` / `p`). Both are // replaceable events, so we emit them on EVERY send rather than gating on @@ -398,4 +408,183 @@ mod tests { assert!(body.contains("took action on your content")); assert!(body.contains("Off-topic.")); } + + #[tokio::test] + #[ignore = "requires Postgres"] + async fn delivered_notice_retry_preserves_a_later_user_hide() { + use nostr::Keys; + use sqlx::{PgPool, Row}; + + let admin_url = std::env::var("TEST_DATABASE_URL") + .unwrap_or_else(|_| "postgres://buzz:buzz_dev@localhost:5432/buzz".into()); + let admin = PgPool::connect(&admin_url).await.expect("connect admin"); + let scratch_name = format!("moderation_notice_{}", Uuid::new_v4().simple()); + sqlx::query(sqlx::AssertSqlSafe(format!( + "CREATE DATABASE {scratch_name}" + ))) + .execute(&admin) + .await + .expect("create scratch database"); + let slash = admin_url.rfind('/').expect("database URL path"); + let scratch_url = format!("{}/{}", &admin_url[..slash], scratch_name); + let pool = PgPool::connect(&scratch_url) + .await + .expect("connect scratch database"); + buzz_db::migration::run_migrations(&pool) + .await + .expect("migrate scratch database"); + + let community_uuid = Uuid::new_v4(); + let host = format!("moderation-{}.example", community_uuid.simple()); + sqlx::query("INSERT INTO communities (id, host) VALUES ($1, $2)") + .bind(community_uuid) + .bind(&host) + .execute(&pool) + .await + .expect("insert community"); + let tenant = + TenantContext::resolved(buzz_core::CommunityId::from_uuid(community_uuid), host); + let relay_keys = Keys::generate(); + let recipient = Keys::generate(); + let recipient_bytes = recipient.public_key().to_bytes(); + + let mut config = crate::config::Config::from_env().expect("default config"); + config.database_url = scratch_url; + config.read_database_url = None; + config.require_relay_membership = false; + config.redis_url = "redis://127.0.0.1:1".into(); + let db = buzz_db::Db::from_pool(pool.clone()); + let redis_pool = deadpool_redis::Config::from_url(&config.redis_url) + .create_pool(Some(deadpool_redis::Runtime::Tokio1)) + .expect("redis pool"); + let pubsub = Arc::new( + buzz_pubsub::PubSubManager::new(&config.redis_url, redis_pool.clone()) + .await + .expect("pubsub manager"), + ); + let audit = buzz_audit::AuditService::new(pool.clone()); + let auth = buzz_auth::AuthService::new(config.auth.clone()); + let search = buzz_search::SearchService::new(pool.clone()); + let workflow_engine = Arc::new(buzz_workflow::WorkflowEngine::new( + db.clone(), + buzz_workflow::WorkflowConfig::default(), + )); + let media_storage = buzz_media::MediaStorage::new(&config.media).expect("media storage"); + let (state, audit_shutdown) = AppState::new( + config, + db, + redis_pool, + audit, + pubsub, + auth, + search, + workflow_engine, + relay_keys.clone(), + media_storage, + ); + let state = Arc::new(state); + + let notice = ModerationNotice::Restriction { + action_id: Uuid::new_v4(), + kind: "timeout".into(), + public_reason: "Cool off.".into(), + }; + send_moderation_notice(&tenant, &state, recipient_bytes.as_slice(), notice.clone()) + .await + .expect("deliver notice"); + + let participant_hash = buzz_db::dm::compute_participant_hash(&[ + recipient_bytes.as_slice(), + relay_keys.public_key().to_bytes().as_slice(), + ]); + let dm = state + .db + .find_dm_by_participants(tenant.community(), &participant_hash) + .await + .expect("find moderation DM") + .expect("moderation DM exists"); + state + .db + .hide_dm(tenant.community(), dm.id, recipient_bytes.as_slice()) + .await + .expect("hide moderation DM"); + publish_dm_visibility_snapshot(&tenant, &state, recipient_bytes.as_slice()) + .await + .expect("publish hidden snapshot"); + + let notice_count_before: i64 = sqlx::query_scalar( + "SELECT count(*) FROM events \ + WHERE community_id = $1 AND channel_id = $2 AND kind = $3 \ + AND pubkey = $4 AND deleted_at IS NULL", + ) + .bind(tenant.community().as_uuid()) + .bind(dm.id) + .bind(KIND_STREAM_MESSAGE as i32) + .bind(relay_keys.public_key().to_bytes().as_slice()) + .fetch_one(&pool) + .await + .expect("count notices before retry"); + + send_moderation_notice(&tenant, &state, recipient_bytes.as_slice(), notice) + .await + .expect("retry delivered notice"); + + let hidden: bool = sqlx::query( + "SELECT hidden_at IS NOT NULL AS hidden FROM channel_members \ + WHERE community_id = $1 AND channel_id = $2 AND pubkey = $3", + ) + .bind(tenant.community().as_uuid()) + .bind(dm.id) + .bind(recipient_bytes.as_slice()) + .fetch_one(&pool) + .await + .expect("read hidden state") + .try_get("hidden") + .expect("decode hidden state"); + assert!(hidden, "duplicate notice must preserve the user's hide"); + + let snapshot = state + .db + .query_events(&buzz_db::event::EventQuery { + kinds: Some(vec![buzz_core::kind::KIND_DM_VISIBILITY as i32]), + pubkey: Some(relay_keys.public_key().to_bytes().to_vec()), + d_tag: Some(recipient.public_key().to_hex()), + limit: Some(1), + ..buzz_db::event::EventQuery::for_community(tenant.community()) + }) + .await + .expect("read visibility snapshot") + .into_iter() + .next() + .expect("visibility snapshot exists"); + assert!(snapshot.event.tags.iter().any(|tag| { + let parts = tag.as_slice(); + parts.len() >= 2 && parts[0] == "h" && parts[1] == dm.id.to_string() + })); + + let notice_count_after: i64 = sqlx::query_scalar( + "SELECT count(*) FROM events \ + WHERE community_id = $1 AND channel_id = $2 AND kind = $3 \ + AND pubkey = $4 AND deleted_at IS NULL", + ) + .bind(tenant.community().as_uuid()) + .bind(dm.id) + .bind(KIND_STREAM_MESSAGE as i32) + .bind(relay_keys.public_key().to_bytes().as_slice()) + .fetch_one(&pool) + .await + .expect("count notices after retry"); + assert_eq!(notice_count_after, notice_count_before); + + audit_shutdown + .drain(std::time::Duration::from_secs(5)) + .await; + drop(state); + pool.close().await; + let _ = sqlx::query(sqlx::AssertSqlSafe(format!( + "DROP DATABASE IF EXISTS {scratch_name} WITH (FORCE)" + ))) + .execute(&admin) + .await; + } } diff --git a/crates/buzz-relay/src/handlers/side_effects.rs b/crates/buzz-relay/src/handlers/side_effects.rs index 05bfa8695a..a174a2be7a 100644 --- a/crates/buzz-relay/src/handlers/side_effects.rs +++ b/crates/buzz-relay/src/handlers/side_effects.rs @@ -3415,60 +3415,50 @@ pub async fn publish_dm_visibility_snapshot( Ok(()) } -/// Repair relay-authored DM visibility snapshots from canonical membership -/// rows across every active community. +/// Publish one bounded batch from the durable DM visibility dirty-viewer queue. /// -/// This is the durable retry path for a snapshot publication that fails after -/// a hide/unhide mutation commits. The sweep is safe at startup and -/// periodically because it publishes only viewers whose current `h` tags -/// differ from `channel_members.hidden_at`. +/// Hide/unhide mutations enqueue their viewer in the same transaction as the +/// canonical membership change. This worker therefore does work proportional +/// to failed projections and never scans deployment-wide DM history. pub async fn reconcile_dm_visibility_snapshots(state: &Arc) -> anyhow::Result { - const BATCH_LIMIT: i64 = 1_000; + const BATCH_LIMIT: i64 = 100; + const CLAIM_LEASE_SECONDS: i64 = 60; - let communities = state.db.usage_community_hosts().await?; - let relay_pubkey = state.relay_keypair.public_key(); + let claims = state + .db + .claim_dm_visibility_dirty_viewers(BATCH_LIMIT, CLAIM_LEASE_SECONDS) + .await?; let mut reconciled = 0usize; - for community in communities { - let community_id = buzz_core::CommunityId::from_uuid(community.id); - let host = community.host; - match state.db.is_community_active(community_id).await { - Ok(true) => {} - Ok(false) => continue, + for claim in claims { + let tenant = TenantContext::resolved(claim.community_id, claim.community_host.clone()); + match publish_dm_visibility_snapshot(&tenant, state, &claim.viewer).await { + Ok(()) => reconciled += 1, Err(error) => { metrics::counter!("buzz_dm_visibility_reconciliation_failures_total").increment(1); - warn!(%community_id, %host, %error, "DM visibility lifecycle check failed"); - continue; - } - } - let viewers = match state - .db - .dm_visibility_viewers_needing_reconciliation(community_id, &relay_pubkey, BATCH_LIMIT) - .await - { - Ok(viewers) => viewers, - Err(error) => { - metrics::counter!("buzz_dm_visibility_reconciliation_failures_total").increment(1); - warn!(%community_id, %host, %error, "DM visibility drift scan failed"); - continue; - } - }; - - let tenant = TenantContext::resolved(community_id, host.clone()); - for viewer in viewers { - match publish_dm_visibility_snapshot(&tenant, state, &viewer).await { - Ok(()) => reconciled += 1, - Err(error) => { - metrics::counter!("buzz_dm_visibility_reconciliation_failures_total") - .increment(1); + if let Err(retry_error) = state + .db + .retry_dm_visibility_dirty_viewer( + claim.community_id, + &claim.viewer, + claim.claim_id, + ) + .await + { warn!( - %community_id, - %host, - viewer = %hex::encode(&viewer), - %error, - "DM visibility snapshot reconciliation failed" + community_id = %claim.community_id, + viewer = %hex::encode(&claim.viewer), + %retry_error, + "DM visibility retry release failed; claim lease will recover it" ); } + warn!( + community_id = %claim.community_id, + host = %claim.community_host, + viewer = %hex::encode(&claim.viewer), + %error, + "DM visibility snapshot reconciliation failed" + ); } } } diff --git a/crates/buzz-relay/src/main.rs b/crates/buzz-relay/src/main.rs index b2b273db90..7465f108a0 100644 --- a/crates/buzz-relay/src/main.rs +++ b/crates/buzz-relay/src/main.rs @@ -559,17 +559,8 @@ async fn main() -> anyhow::Result<()> { } } - // NIP-DV: repair any viewer snapshot publication that failed after the - // canonical hidden-state mutation committed. Run once before accepting - // traffic, then periodically so transient failures converge without - // requiring another message in that DM. - match buzz_relay::handlers::side_effects::reconcile_dm_visibility_snapshots(&state).await { - Ok(count) => info!(count, "DM visibility snapshots reconciled on startup"), - Err(error) => { - tracing::warn!(%error, "DM visibility snapshot startup reconciliation failed") - } - } - + // NIP-DV: process the durable dirty-viewer queue in bounded batches. The + // task's first interval tick is immediate but never delays listener startup. { let reconcile_state = Arc::clone(&state); let interval_secs = std::env::var("BUZZ_DM_VISIBILITY_RECONCILE_INTERVAL_SECS") @@ -579,7 +570,6 @@ async fn main() -> anyhow::Result<()> { .max(1); tokio::spawn(async move { let mut interval = tokio::time::interval(std::time::Duration::from_secs(interval_secs)); - interval.tick().await; loop { interval.tick().await; match buzz_relay::handlers::side_effects::reconcile_dm_visibility_snapshots( diff --git a/migrations/0032_dm_visibility_dirty_viewers.sql b/migrations/0032_dm_visibility_dirty_viewers.sql new file mode 100644 index 0000000000..bdced1a210 --- /dev/null +++ b/migrations/0032_dm_visibility_dirty_viewers.sql @@ -0,0 +1,32 @@ +-- Durable, bounded retry queue for relay-authored DM visibility projections. +-- The canonical channel_members mutation and this dirty marker commit together; +-- workers claim only indexed due rows instead of scanning DM membership history. +SET LOCAL lock_timeout = '5s'; + +CREATE TABLE dm_visibility_dirty_viewers ( + community_id UUID NOT NULL REFERENCES communities(id), + viewer BYTEA NOT NULL CHECK (length(viewer) = 32), + generation BIGINT NOT NULL DEFAULT 1 CHECK (generation > 0), + state TEXT NOT NULL DEFAULT 'pending' + CHECK (state IN ('pending', 'publishing')), + dirty_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + claim_id UUID, + lease_until TIMESTAMPTZ, + attempts INTEGER NOT NULL DEFAULT 0 CHECK (attempts >= 0), + PRIMARY KEY (community_id, viewer), + CHECK ( + (state = 'pending' AND claim_id IS NULL AND lease_until IS NULL) + OR (state = 'publishing' AND claim_id IS NOT NULL AND lease_until IS NOT NULL) + ) +); + +CREATE INDEX dm_visibility_dirty_viewers_due + ON dm_visibility_dirty_viewers (next_attempt_at, dirty_at, community_id, viewer) + WHERE state = 'pending'; + +CREATE INDEX dm_visibility_dirty_viewers_recovery + ON dm_visibility_dirty_viewers (lease_until, community_id, viewer) + WHERE state = 'publishing'; + +SELECT attach_community_write_fence('dm_visibility_dirty_viewers'); diff --git a/schema/schema.sql b/schema/schema.sql index 6e14e6be1b..55ec8f5f21 100644 --- a/schema/schema.sql +++ b/schema/schema.sql @@ -160,6 +160,33 @@ CREATE TABLE channel_members ( CREATE INDEX idx_channel_members_pubkey ON channel_members (community_id, pubkey) WHERE removed_at IS NULL; +-- Durable retry queue for relay-authored kind:30622 DM visibility snapshots. +CREATE TABLE dm_visibility_dirty_viewers ( + community_id UUID NOT NULL REFERENCES communities(id), + viewer BYTEA NOT NULL CHECK (length(viewer) = 32), + generation BIGINT NOT NULL DEFAULT 1 CHECK (generation > 0), + state TEXT NOT NULL DEFAULT 'pending' + CHECK (state IN ('pending', 'publishing')), + dirty_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + claim_id UUID, + lease_until TIMESTAMPTZ, + attempts INTEGER NOT NULL DEFAULT 0 CHECK (attempts >= 0), + PRIMARY KEY (community_id, viewer), + CHECK ( + (state = 'pending' AND claim_id IS NULL AND lease_until IS NULL) + OR (state = 'publishing' AND claim_id IS NOT NULL AND lease_until IS NOT NULL) + ) +); + +CREATE INDEX dm_visibility_dirty_viewers_due + ON dm_visibility_dirty_viewers (next_attempt_at, dirty_at, community_id, viewer) + WHERE state = 'pending'; + +CREATE INDEX dm_visibility_dirty_viewers_recovery + ON dm_visibility_dirty_viewers (lease_until, community_id, viewer) + WHERE state = 'publishing'; + -- ── Users ───────────────────────────────────────────────────────────────────── -- Conformance: "Users, profiles, NIP-05, and user search". One profile per -- (community, pubkey): the same key reposts kind:0 in each community it joins. @@ -1726,6 +1753,7 @@ SELECT attach_community_write_fence('channel_members'); SELECT attach_community_write_fence('channels'); SELECT attach_community_write_fence('community_bans'); SELECT attach_community_write_fence('delivery_log'); +SELECT attach_community_write_fence('dm_visibility_dirty_viewers'); SELECT attach_community_write_fence('event_mentions'); SELECT attach_community_write_fence('events'); SELECT attach_community_write_fence('git_repo_names');