lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

visibility_reads.rs (16382B)


      1 use super::*;
      2 use radroots_event::id::Nip01Coordinate;
      3 use radroots_storage::event::VisibilityIndexBounds;
      4 
      5 type Transaction<'a> = sqlx::Transaction<'a, Sqlite>;
      6 
      7 impl SqliteStorage {
      8     pub(super) async fn visibility_header(
      9         &self,
     10         transaction: &mut Transaction<'_>,
     11         expected: Option<EventSourceToken>,
     12     ) -> Result<EventStoreStatus, Error> {
     13         let sql = "SELECT source.mutation_epoch, source.sequence_head, progress.ready,
     14                    progress.replay_epoch, progress.raw_events, progress.verified_events,
     15                    progress.visible_events
     16                    FROM radroots_runtime_source_generations AS source
     17                    LEFT JOIN radroots_runtime_visibility_progress AS progress
     18                      ON progress.source_generation = source.generation
     19                    WHERE source.generation = ? AND source.state = 'active'";
     20         #[cfg(test)]
     21         self.work.request(work::Read::Aggregate, sql);
     22         let row = sqlx::query(sql)
     23             .bind(self.generation.as_bytes().as_slice())
     24             .fetch_optional(&mut **transaction)
     25             .await
     26             .map_err(map_backend)?
     27             .ok_or(Error::SourceGenerationChanged)?;
     28         #[cfg(test)]
     29         self.work.aggregate_returned();
     30         let epoch = u64_from_i64(row.try_get("mutation_epoch").map_err(map_corrupt)?)?;
     31         if expected.is_some_and(|token| token != EventSourceToken::new(self.generation, epoch)) {
     32             return Err(Error::SourceEpochChanged);
     33         }
     34         let ready: Option<bool> = row.try_get("ready").map_err(map_corrupt)?;
     35         if ready != Some(true) {
     36             return Err(Error::VisibilityRebuilding);
     37         }
     38         let replay = u64_from_i64(row.try_get("replay_epoch").map_err(map_corrupt)?)?;
     39         let raw = u64_from_i64(row.try_get("raw_events").map_err(map_corrupt)?)?;
     40         let sequence = u64_from_i64(row.try_get("sequence_head").map_err(map_corrupt)?)?;
     41         if replay != epoch || raw != sequence {
     42             return Err(Error::CorruptStoredEvent);
     43         }
     44         EventStoreStatus::new(
     45             self.generation,
     46             self.mode,
     47             EventStoreHealth::Available,
     48             raw,
     49             u64_from_i64(row.try_get("verified_events").map_err(map_corrupt)?)?,
     50             u64_from_i64(row.try_get("visible_events").map_err(map_corrupt)?)?,
     51         )
     52     }
     53 
     54     pub(super) async fn indexed_visible_page(
     55         &self,
     56         query: EventQuery,
     57         expected: Option<EventSourceToken>,
     58     ) -> Result<EventPage<StoredVisibleEvent>, Error> {
     59         self.validate_cursor(&query)?;
     60         let mut transaction = self.pool.begin().await.map_err(map_backend)?;
     61         self.visibility_header(&mut transaction, expected).await?;
     62         let after = query
     63             .bounds()
     64             .cursor()
     65             .map_or(0, |cursor| cursor.sequence().get());
     66         let mut builder = QueryBuilder::<Sqlite>::new(
     67             "SELECT member.source_sequence, length(event.signed_event) AS signed_bytes
     68              FROM radroots_runtime_visibility_members AS member INDEXED BY ",
     69         );
     70         if query.event_ids().is_empty() {
     71             builder.push("radroots_runtime_visibility_members_page_idx");
     72         } else {
     73             builder.push("radroots_runtime_visibility_members_event_idx");
     74         }
     75         builder.push(
     76             " JOIN radroots_runtime_events AS event ON event.event_id = member.event_id
     77              WHERE member.source_generation = ",
     78         );
     79         builder.push_bind(self.generation.as_bytes().as_slice());
     80         builder
     81             .push(" AND member.visible = 1 AND member.source_sequence > ")
     82             .push_bind(i64_from_u64(after)?);
     83         if !query.event_ids().is_empty() {
     84             builder.push(" AND member.event_id IN (");
     85             let mut ids = builder.separated(", ");
     86             for id in query.event_ids() {
     87                 ids.push_bind(id.as_bytes().to_vec());
     88             }
     89             ids.push_unseparated(")");
     90         }
     91         builder
     92             .push(" ORDER BY member.source_sequence LIMIT ")
     93             .push_bind(i64::from(query.bounds().limit()) + 1);
     94         #[cfg(test)]
     95         self.work.request(work::Read::Keys, builder.sql().as_str());
     96         let lengths = builder
     97             .build()
     98             .fetch_all(&mut *transaction)
     99             .await
    100             .map_err(map_backend)?;
    101         #[cfg(test)]
    102         self.work.keys_returned(lengths.len());
    103         let mut charged = 4096 + (u64::from(query.bounds().limit()) + 1) * 128;
    104         let mut items = Vec::new();
    105         let mut more = false;
    106         for row in lengths {
    107             if items.len() == usize::from(query.bounds().limit()) {
    108                 more = true;
    109                 break;
    110             }
    111             let sequence: i64 = row.try_get("source_sequence").map_err(map_corrupt)?;
    112             let bytes = u64_from_i64(row.try_get("signed_bytes").map_err(map_corrupt)?)?;
    113             let next_charge = charged
    114                 .checked_add(VisibilityIndexBounds::charge(bytes)?)
    115                 .ok_or(Error::SpaceInsufficient)?;
    116             if next_charge > 16 * 1024 * 1024 {
    117                 if items.is_empty() {
    118                     return Err(Error::SpaceInsufficient);
    119                 }
    120                 more = true;
    121                 break;
    122             }
    123             let sql = "SELECT source_generation, source_sequence, signed_event, admission_stage,
    124                        admitted_contract_id, admitted_registry_version
    125                        FROM radroots_runtime_events WHERE source_generation = ? AND source_sequence = ?";
    126             #[cfg(test)]
    127             self.work.request(work::Read::Bounded, sql);
    128             let payload = sqlx::query(sql)
    129                 .bind(self.generation.as_bytes().as_slice())
    130                 .bind(sequence)
    131                 .fetch_one(&mut *transaction)
    132                 .await
    133                 .map_err(map_backend)?;
    134             #[cfg(test)]
    135             self.work.returned(std::slice::from_ref(&payload));
    136             let decoded = self.decode_event_row(&payload)?;
    137             if decoded.raw_json.len() as u64 != bytes || decoded.stage != AdmissionStage::Visible {
    138                 return Err(Error::CorruptStoredEvent);
    139             }
    140             items.push(StoredVisibleEvent::new(decoded.position, decoded.event));
    141             charged = next_charge;
    142         }
    143         let next = more
    144             .then(|| items.last().map(StoredVisibleEvent::position))
    145             .flatten();
    146         transaction.commit().await.map_err(map_backend)?;
    147         EventPage::new(self.generation, items, next, query.bounds())
    148     }
    149 
    150     pub(super) async fn update_visibility_membership(
    151         &self,
    152         transaction: &mut Transaction<'_>,
    153         position: i64,
    154     ) -> Result<(), Error> {
    155         let row = sqlx::query(
    156             "SELECT event_id, admission_stage, head_coordinate, created_at
    157              FROM radroots_runtime_visibility_events WHERE source_generation = ? AND source_sequence = ?")
    158             .bind(self.generation.as_bytes().as_slice()).bind(position)
    159             .fetch_one(&mut **transaction).await.map_err(map_backend)?;
    160         let id: Vec<u8> = row.try_get("event_id").map_err(map_corrupt)?;
    161         let stage: String = row.try_get("admission_stage").map_err(map_corrupt)?;
    162         sqlx::query(
    163             "INSERT INTO radroots_runtime_visibility_members
    164              (source_generation, source_sequence, event_id, admission_stage, visible)
    165              VALUES (?, ?, ?, ?, 0) ON CONFLICT(source_generation, source_sequence)
    166              DO UPDATE SET admission_stage = excluded.admission_stage",
    167         )
    168         .bind(self.generation.as_bytes().as_slice())
    169         .bind(position)
    170         .bind(&id)
    171         .bind(stage)
    172         .execute(&mut **transaction)
    173         .await
    174         .map_err(map_backend)?;
    175         let coordinate: Option<Vec<u8>> = row.try_get("head_coordinate").map_err(map_corrupt)?;
    176         if let Some(coordinate) = coordinate {
    177             let old = sqlx::query(
    178                 "SELECT head.source_sequence, metadata.created_at, metadata.event_id
    179                  FROM radroots_runtime_visibility_heads AS head
    180                  JOIN radroots_runtime_visibility_events AS metadata ON metadata.event_id = head.event_id
    181                  WHERE head.source_generation = ? AND head.head_coordinate = ?")
    182                 .bind(self.generation.as_bytes().as_slice()).bind(&coordinate)
    183                 .fetch_optional(&mut **transaction).await.map_err(map_backend)?;
    184             let time: Vec<u8> = row.try_get("created_at").map_err(map_corrupt)?;
    185             let replace = match &old {
    186                 None => true,
    187                 Some(old) => {
    188                     let old_time: Vec<u8> = old.try_get("created_at").map_err(map_corrupt)?;
    189                     let old_id: Vec<u8> = old.try_get("event_id").map_err(map_corrupt)?;
    190                     time > old_time || (time == old_time && id < old_id)
    191                 }
    192             };
    193             if replace {
    194                 sqlx::query(
    195                     "INSERT INTO radroots_runtime_visibility_heads
    196                      (source_generation, head_coordinate, source_sequence, event_id) VALUES (?, ?, ?, ?)
    197                      ON CONFLICT(source_generation, head_coordinate) DO UPDATE SET
    198                      source_sequence = excluded.source_sequence, event_id = excluded.event_id")
    199                     .bind(self.generation.as_bytes().as_slice()).bind(coordinate).bind(position).bind(id)
    200                     .execute(&mut **transaction).await.map_err(map_backend)?;
    201                 if let Some(old) = old {
    202                     let previous = old.try_get("source_sequence").map_err(map_corrupt)?;
    203                     self.refresh_visibility_member(transaction, previous)
    204                         .await?;
    205                 }
    206             }
    207         }
    208         self.refresh_visibility_member(transaction, position)
    209             .await?;
    210         // Immutable targets persist; this queue changes only membership, not source truth.
    211         sqlx::query(
    212             "INSERT OR IGNORE INTO radroots_runtime_visibility_pending
    213              SELECT source_generation, 0, target_event FROM radroots_runtime_visibility_deletion_events
    214              WHERE request_id = ?")
    215             .bind(row.try_get::<Vec<u8>, _>("event_id").map_err(map_corrupt)?)
    216             .execute(&mut **transaction).await.map_err(map_backend)?;
    217         sqlx::query(
    218             "INSERT OR IGNORE INTO radroots_runtime_visibility_pending
    219              SELECT source_generation, 1, CAST(target_coordinate AS BLOB)
    220              FROM radroots_runtime_visibility_deletion_addresses WHERE request_id = ?",
    221         )
    222         .bind(row.try_get::<Vec<u8>, _>("event_id").map_err(map_corrupt)?)
    223         .execute(&mut **transaction)
    224         .await
    225         .map_err(map_backend)?;
    226         Ok(())
    227     }
    228 
    229     async fn refresh_visibility_member(
    230         &self,
    231         transaction: &mut Transaction<'_>,
    232         position: i64,
    233     ) -> Result<(), Error> {
    234         sqlx::query(
    235             "UPDATE radroots_runtime_visibility_members SET visible = (
    236              SELECT candidate.admission_stage = 'visible' AND candidate.ephemeral = 0
    237              AND (candidate.head_coordinate IS NULL OR candidate.event_id = (
    238                SELECT head.event_id FROM radroots_runtime_visibility_heads AS head
    239                WHERE head.source_generation = candidate.source_generation
    240                  AND head.head_coordinate = candidate.head_coordinate))
    241              AND (candidate.deletion_request = 1 OR (
    242                NOT EXISTS (SELECT 1 FROM radroots_runtime_visibility_deletion_events AS deletion
    243                  WHERE deletion.source_generation = candidate.source_generation
    244                  AND deletion.target_event = candidate.event_id AND deletion.author = candidate.author)
    245                AND NOT EXISTS (SELECT 1 FROM radroots_runtime_visibility_deletion_addresses AS deletion
    246                  WHERE deletion.source_generation = candidate.source_generation
    247                  AND deletion.target_coordinate = candidate.deletion_coordinate
    248                  AND deletion.author = candidate.author AND deletion.created_at >= candidate.created_at)))
    249              FROM radroots_runtime_visibility_events AS candidate
    250              WHERE candidate.source_generation = ? AND candidate.source_sequence = ?)
    251              WHERE source_generation = ? AND source_sequence = ?")
    252             .bind(self.generation.as_bytes().as_slice()).bind(position)
    253             .bind(self.generation.as_bytes().as_slice()).bind(position)
    254             .execute(&mut **transaction).await.map_err(map_backend)?;
    255         Ok(())
    256     }
    257 
    258     pub(super) async fn drain_visibility_keys(
    259         &self,
    260         transaction: &mut Transaction<'_>,
    261         remaining: u16,
    262         charged: &mut u64,
    263         byte_limit: u64,
    264     ) -> Result<u16, Error> {
    265         let keys = sqlx::query(
    266             "SELECT target_type, length(target_key) AS key_bytes FROM radroots_runtime_visibility_pending
    267              WHERE source_generation = ? ORDER BY target_type, target_key LIMIT ?",
    268         )
    269         .bind(self.generation.as_bytes().as_slice())
    270         .bind(i64::from(remaining))
    271         .fetch_all(&mut **transaction)
    272         .await
    273         .map_err(map_backend)?;
    274         let mut processed = 0;
    275         for row in keys {
    276             let kind: i64 = row.try_get("target_type").map_err(map_corrupt)?;
    277             let key_bytes = u64_from_i64(row.try_get("key_bytes").map_err(map_corrupt)?)?;
    278             let charge = charged
    279                 .checked_add(4096 + 16 * key_bytes)
    280                 .ok_or(Error::SpaceInsufficient)?;
    281             if charge > byte_limit {
    282                 break;
    283             }
    284             let key: Vec<u8> = sqlx::query_scalar(
    285                 "SELECT target_key FROM radroots_runtime_visibility_pending
    286                  WHERE source_generation = ? ORDER BY target_type, target_key LIMIT 1",
    287             )
    288             .bind(self.generation.as_bytes().as_slice())
    289             .fetch_one(&mut **transaction)
    290             .await
    291             .map_err(map_backend)?;
    292             if key.len() as u64 != key_bytes {
    293                 return Err(Error::CorruptStoredEvent);
    294             }
    295             let position = if kind == 0 {
    296                 sqlx::query_scalar::<_, i64>(
    297                     "SELECT source_sequence FROM radroots_runtime_visibility_members
    298                    WHERE source_generation = ? AND event_id = ?",
    299                 )
    300                 .bind(self.generation.as_bytes().as_slice())
    301                 .bind(&key)
    302                 .fetch_optional(&mut **transaction)
    303                 .await
    304                 .map_err(map_backend)?
    305             } else {
    306                 let coordinate =
    307                     std::str::from_utf8(&key).map_err(|_| Error::CorruptStoredEvent)?;
    308                 let coordinate =
    309                     Nip01Coordinate::parse(coordinate).map_err(|_| Error::CorruptStoredEvent)?;
    310                 let mut head = vec![u8::from(coordinate.kind() >= 30_000)];
    311                 head.extend_from_slice(&coordinate.kind().to_be_bytes());
    312                 head.extend_from_slice(coordinate.pubkey().as_bytes());
    313                 if coordinate.kind() >= 30_000 {
    314                     head.extend_from_slice(coordinate.identifier().as_bytes());
    315                 }
    316                 sqlx::query_scalar::<_, i64>(
    317                     "SELECT source_sequence FROM radroots_runtime_visibility_heads
    318                    WHERE source_generation = ? AND head_coordinate = ?",
    319                 )
    320                 .bind(self.generation.as_bytes().as_slice())
    321                 .bind(head)
    322                 .fetch_optional(&mut **transaction)
    323                 .await
    324                 .map_err(map_backend)?
    325             };
    326             if let Some(position) = position {
    327                 self.refresh_visibility_member(transaction, position)
    328                     .await?;
    329             }
    330             sqlx::query(
    331                 "DELETE FROM radroots_runtime_visibility_pending
    332                 WHERE source_generation = ? AND target_type = ? AND target_key = ?",
    333             )
    334             .bind(self.generation.as_bytes().as_slice())
    335             .bind(kind)
    336             .bind(key)
    337             .execute(&mut **transaction)
    338             .await
    339             .map_err(map_backend)?;
    340             *charged = charge;
    341             processed += 1;
    342         }
    343         Ok(processed)
    344     }
    345 }