rostra_client_db/
events_content_missing_ops.rs1use 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#[derive(Debug, Clone)]
11pub struct NextMissingContent {
12 pub scheduled_time: Timestamp,
14 pub author: RostraId,
16 pub event_id: ShortEventId,
18 pub fetch_attempt_count: u16,
20}
21
22impl Database {
23 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 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 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 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 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 events_content_missing_table.remove(&(current_scheduled_time, event_id))?;
170
171 events_content_missing_table.insert(&(next_attempt_at, event_id), &())?;
173
174 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 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}