Skip to main content

rostra_client_db/
events_content_missing_ops.rs

1use rostra_core::event::EventExt as _;
2use rostra_core::id::RostraId;
3use rostra_core::{ShortEventId, Timestamp};
4use tracing::{debug, warn};
5
6use crate::tables::event::EventContentState;
7use crate::{Database, LOG_TARGET, events, events_content_state, tables};
8
9/// Result of peeking at the next missing content entry.
10#[derive(Debug, Clone)]
11pub struct NextMissingContent {
12    /// Scheduled time for the next fetch attempt.
13    pub scheduled_time: Timestamp,
14    /// The author of the event.
15    pub author: RostraId,
16    /// The event whose content is missing.
17    pub event_id: ShortEventId,
18    /// How many fetch attempts have been made so far.
19    pub fetch_attempt_count: u16,
20}
21
22impl Database {
23    /// Check if an event's content is in the missing state.
24    pub async fn is_event_content_missing(&self, event_id: ShortEventId) -> bool {
25        self.read_with(|tx| {
26            let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
27            Ok(matches!(
28                events_content_state_table
29                    .get(&event_id)?
30                    .map(|g| g.value()),
31                Some(EventContentState::Missing { .. })
32            ))
33        })
34        .await
35        .expect("Storage error")
36    }
37
38    /// Peek at the next missing content entry (earliest scheduled fetch).
39    ///
40    /// Transactionally removes inconsistent entries from the front of
41    /// `events_content_missing`, then returns the first entry whose timestamp
42    /// matches the event's current `Missing` state. Returns `None` if no valid
43    /// entry remains.
44    pub async fn peek_next_missing_content(&self) -> Option<NextMissingContent> {
45        self.write_with(|tx| {
46            let events_table = tx.open_table(&events::TABLE)?;
47            let mut events_content_missing_table =
48                tx.open_table(&tables::events_content_missing::TABLE)?;
49            let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
50
51            loop {
52                let Some((scheduled_time, event_id)) = events_content_missing_table
53                    .first()?
54                    .map(|first| first.0.value())
55                else {
56                    return Ok(None);
57                };
58
59                let fetch_attempt_count = match events_content_state_table
60                    .get(&event_id)?
61                    .map(|g| g.value())
62                {
63                    Some(EventContentState::Missing {
64                        fetch_attempt_count,
65                        next_fetch_attempt,
66                        ..
67                    }) if next_fetch_attempt == scheduled_time => fetch_attempt_count,
68                    state => {
69                        warn!(
70                            target: LOG_TARGET,
71                            %event_id,
72                            %scheduled_time,
73                            ?state,
74                            "Removing inconsistent content fetch schedule entry"
75                        );
76                        events_content_missing_table.remove(&(scheduled_time, event_id))?;
77                        continue;
78                    }
79                };
80
81                let Some(event) = events_table.get(&event_id)?.map(|e| e.value()) else {
82                    warn!(
83                        target: LOG_TARGET,
84                        %event_id,
85                        %scheduled_time,
86                        "Removing content fetch schedule entry without an event"
87                    );
88                    events_content_missing_table.remove(&(scheduled_time, event_id))?;
89                    continue;
90                };
91
92                return Ok(Some(NextMissingContent {
93                    scheduled_time,
94                    author: event.signed.author(),
95                    event_id,
96                    fetch_attempt_count,
97                }));
98            }
99        })
100        .await
101        .expect("Storage error")
102    }
103
104    /// Record a failed content fetch attempt.
105    ///
106    /// Updates the `events_content_missing` schedule entry and the
107    /// `events_content_state` metadata for the given event.
108    ///
109    /// The caller provides both the factual time of the attempt
110    /// (`attempted_at`) and the scheduling decision (`next_attempt_at`).
111    /// The backoff calculation lives in the fetcher, not in the DB layer.
112    ///
113    /// The update is compare-and-set against `old_scheduled_time`. If another
114    /// completion or a terminal content transition already changed the current
115    /// state, this stale completion has no effect. The replacement schedule
116    /// must be strictly later than the observed schedule so a schedule value
117    /// cannot be reused as an ABA-prone compare-and-set token.
118    pub async fn record_failed_content_fetch(
119        &self,
120        event_id: ShortEventId,
121        old_scheduled_time: Timestamp,
122        attempted_at: Timestamp,
123        next_attempt_at: Timestamp,
124    ) {
125        self.write_with(|tx| {
126            let mut events_content_missing_table =
127                tx.open_table(&tables::events_content_missing::TABLE)?;
128            let mut events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
129
130            // Read current state
131            let old_state = events_content_state_table
132                .get(&event_id)?
133                .map(|g| g.value());
134
135            let Some(EventContentState::Missing {
136                fetch_attempt_count,
137                next_fetch_attempt: current_scheduled_time,
138                ..
139            }) = old_state
140            else {
141                // Not in Missing state anymore (was processed, deleted, etc.)
142                // Nothing to update.
143                return Ok(());
144            };
145
146            if old_scheduled_time != current_scheduled_time {
147                debug!(
148                    target: LOG_TARGET,
149                    %event_id,
150                    %old_scheduled_time,
151                    %current_scheduled_time,
152                    "Ignoring stale failed content fetch completion"
153                );
154                return Ok(());
155            }
156
157            if next_attempt_at <= current_scheduled_time {
158                warn!(
159                    target: LOG_TARGET,
160                    %event_id,
161                    %current_scheduled_time,
162                    %next_attempt_at,
163                    "Ignoring failed content fetch completion with a non-forward schedule"
164                );
165                return Ok(());
166            }
167
168            // Remove the schedule entry mirrored by the current state.
169            events_content_missing_table.remove(&(current_scheduled_time, event_id))?;
170
171            // Insert new schedule entry with updated time
172            events_content_missing_table.insert(&(next_attempt_at, event_id), &())?;
173
174            // Update state with new attempt metadata
175            let new_count = fetch_attempt_count.saturating_add(1);
176            events_content_state_table.insert(
177                &event_id,
178                &EventContentState::Missing {
179                    last_fetch_attempt: Some(attempted_at),
180                    fetch_attempt_count: new_count,
181                    next_fetch_attempt: next_attempt_at,
182                },
183            )?;
184
185            Ok(())
186        })
187        .await
188        .expect("Storage error")
189    }
190
191    /// Paginate through missing content entries.
192    ///
193    /// Returns events sorted by their next scheduled fetch time. Inconsistent
194    /// rows are omitted; fetcher peeking performs their transactional removal.
195    pub async fn paginate_missing_events_contents(
196        &self,
197        cursor: Option<(Timestamp, ShortEventId)>,
198        limit: usize,
199    ) -> (
200        Vec<(RostraId, ShortEventId)>,
201        Option<(Timestamp, ShortEventId)>,
202    ) {
203        self.read_with(|tx| {
204            let events_table = tx.open_table(&events::TABLE)?;
205            let events_content_missing_table =
206                tx.open_table(&tables::events_content_missing::TABLE)?;
207            let events_content_state_table = tx.open_table(&events_content_state::TABLE)?;
208
209            Self::paginate_table(
210                &events_content_missing_table,
211                cursor,
212                limit,
213                move |(scheduled_time, event_id), _| {
214                    if !matches!(
215                        events_content_state_table
216                            .get(&event_id)?
217                            .map(|state| state.value()),
218                        Some(EventContentState::Missing {
219                            next_fetch_attempt,
220                            ..
221                        }) if next_fetch_attempt == scheduled_time
222                    ) {
223                        return Ok(None);
224                    }
225
226                    let Some(event) = events_table.get(&event_id)?.map(|e| e.value()) else {
227                        warn!(
228                            target: LOG_TARGET,
229                            %event_id,
230                            "Missing event for content_missing event?!"
231                        );
232                        return Ok(None);
233                    };
234
235                    Ok(Some((event.signed.author(), event_id)))
236                },
237            )
238        })
239        .await
240        .expect("Storage error")
241    }
242}