lib

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

mod.rs (44910B)


      1 use crate::backend::map_backend;
      2 mod visibility_index;
      3 #[cfg(test)]
      4 mod visibility_index_tests;
      5 mod visibility_reads;
      6 #[cfg(test)]
      7 mod visibility_reads_tests;
      8 use radroots_event::SignedEvent;
      9 use radroots_event_codec::Codec;
     10 use radroots_storage::{
     11     Error, EventStore,
     12     event::{
     13         AdmissionDisposition, AdmissionReceipt, AdmissionStage, BoxFuture, EventAdmission,
     14         EventCursor, EventId, EventPage, EventPosition, EventQuery, EventQueryBounds,
     15         EventSequence, EventSourceToken, SourceGeneration, StoredEventProvenance, StoredRawEvent,
     16         StoredVerifiedEvent, StoredVisibleEvent, VisibilityEvaluation, VisibilityInput,
     17         VisibilitySnapshot, evaluate_visibility,
     18     },
     19     status::{EventStoreHealth, EventStoreMode, EventStoreStatus},
     20 };
     21 use sqlx::{QueryBuilder, Row, Sqlite, SqlitePool};
     22 use std::{
     23     path::PathBuf,
     24     sync::{Arc, Mutex},
     25 };
     26 
     27 use crate::lock::WriterLock;
     28 use crate::status::StorageLifecycle;
     29 
     30 #[derive(Clone)]
     31 pub struct SqliteStorage {
     32     pub(crate) pool: SqlitePool,
     33     pub(crate) private_pool: SqlitePool,
     34     pub(crate) generation: SourceGeneration,
     35     pub(crate) mode: EventStoreMode,
     36     pub(crate) lifecycle: Arc<StorageLifecycle>,
     37     pub(crate) backup_root: Option<Arc<PathBuf>>,
     38     pub(crate) paths: Option<Arc<crate::Paths>>,
     39     pub(crate) reliability: Arc<Mutex<crate::backup::ReliabilityState>>,
     40     #[cfg(test)]
     41     work: Arc<work::Observer>,
     42 }
     43 
     44 struct StoredEventRow {
     45     position: EventPosition,
     46     raw_json: String,
     47     event: SignedEvent,
     48     stage: AdmissionStage,
     49 }
     50 
     51 impl SqliteStorage {
     52     #[allow(dead_code)] // Single-pool in-memory scaffold retained for focused backend tests.
     53     pub(crate) fn new(
     54         pool: SqlitePool,
     55         generation: SourceGeneration,
     56         mode: EventStoreMode,
     57     ) -> Self {
     58         Self {
     59             private_pool: pool.clone(),
     60             pool,
     61             generation,
     62             mode,
     63             lifecycle: Arc::new(StorageLifecycle::scaffold(mode)),
     64             backup_root: None,
     65             paths: None,
     66             reliability: Arc::new(Mutex::new(crate::backup::ReliabilityState::default())),
     67             #[cfg(test)]
     68             work: Arc::default(),
     69         }
     70     }
     71 
     72     #[allow(dead_code)] // Two-pool in-memory scaffold retained for focused backend tests.
     73     pub(crate) fn with_private_pool(
     74         pool: SqlitePool,
     75         private_pool: SqlitePool,
     76         generation: SourceGeneration,
     77         mode: EventStoreMode,
     78     ) -> Self {
     79         Self {
     80             pool,
     81             private_pool,
     82             generation,
     83             mode,
     84             lifecycle: Arc::new(StorageLifecycle::scaffold(mode)),
     85             backup_root: None,
     86             paths: None,
     87             reliability: Arc::new(Mutex::new(crate::backup::ReliabilityState::default())),
     88             #[cfg(test)]
     89             work: Arc::default(),
     90         }
     91     }
     92 
     93     pub(crate) fn from_opened(
     94         pool: SqlitePool,
     95         private_pool: SqlitePool,
     96         generation: SourceGeneration,
     97         options: &crate::OpenOptions,
     98         writer_lock: Option<WriterLock>,
     99     ) -> Self {
    100         let mode = if options.mode().is_writable() {
    101             EventStoreMode::ReadWrite
    102         } else {
    103             EventStoreMode::ReadOnly
    104         };
    105         Self {
    106             pool,
    107             private_pool,
    108             generation,
    109             mode,
    110             lifecycle: Arc::new(StorageLifecycle::new(
    111                 options.mode(),
    112                 options.busy_timeout(),
    113                 writer_lock,
    114             )),
    115             backup_root: options
    116                 .backup_root()
    117                 .map(|path| Arc::new(path.to_path_buf())),
    118             paths: Some(Arc::new(options.paths().clone())),
    119             reliability: Arc::new(Mutex::new(crate::backup::ReliabilityState::default())),
    120             #[cfg(test)]
    121             work: Arc::default(),
    122         }
    123     }
    124 
    125     pub(crate) const fn pool(&self) -> &SqlitePool {
    126         &self.pool
    127     }
    128 
    129     pub(crate) const fn private_pool(&self) -> &SqlitePool {
    130         &self.private_pool
    131     }
    132 
    133     pub(crate) const fn event_mode(&self) -> EventStoreMode {
    134         self.mode
    135     }
    136 
    137     async fn selected(
    138         &self,
    139         query: &EventQuery,
    140         minimum_stage: AdmissionStage,
    141     ) -> Result<(Vec<StoredEventRow>, Option<EventCursor>), Error> {
    142         self.validate_cursor(query)?;
    143         let after = query
    144             .bounds()
    145             .cursor()
    146             .map_or(0, |cursor| cursor.sequence().get());
    147         let fetch_limit = u64::from(query.bounds().limit()) + 1;
    148         let mut builder = QueryBuilder::<Sqlite>::new(
    149             "SELECT source_generation, source_sequence, signed_event, admission_stage, \
    150                     admitted_contract_id, admitted_registry_version \
    151              FROM radroots_runtime_events WHERE source_generation = ",
    152         );
    153         builder.push_bind(self.generation.as_bytes().as_slice());
    154         builder.push(" AND source_sequence > ");
    155         builder.push_bind(i64_from_u64(after)?);
    156         if minimum_stage == AdmissionStage::Verified {
    157             builder.push(" AND admission_stage IN ('verified', 'visible')");
    158         } else if minimum_stage == AdmissionStage::Visible {
    159             builder.push(" AND admission_stage = 'visible'");
    160         }
    161         if !query.event_ids().is_empty() {
    162             builder.push(" AND event_id IN (");
    163             let mut separated = builder.separated(", ");
    164             for event_id in query.event_ids() {
    165                 separated.push_bind(event_id.as_bytes().to_vec());
    166             }
    167             separated.push_unseparated(")");
    168         }
    169         builder.push(" ORDER BY source_sequence LIMIT ");
    170         builder.push_bind(i64_from_u64(fetch_limit)?);
    171 
    172         #[cfg(test)]
    173         self.work
    174             .request(work::Read::Bounded, builder.sql().as_str());
    175         let rows = builder
    176             .build()
    177             .fetch_all(&self.pool)
    178             .await
    179             .map_err(map_backend)?;
    180         #[cfg(test)]
    181         self.work.returned(&rows);
    182         let mut decoded = rows
    183             .iter()
    184             .map(|row| self.decode_event_row(row))
    185             .collect::<Result<Vec<_>, _>>()?;
    186         let next = if decoded.len() > usize::from(query.bounds().limit()) {
    187             decoded.truncate(usize::from(query.bounds().limit()));
    188             decoded.last().map(|row| row.position)
    189         } else {
    190             None
    191         };
    192         Ok((decoded, next))
    193     }
    194 
    195     async fn current_event_rows(&self) -> Result<Vec<StoredEventRow>, Error> {
    196         let sql = "SELECT source_generation, source_sequence, signed_event, admission_stage,
    197                     admitted_contract_id, admitted_registry_version
    198              FROM radroots_runtime_events
    199              WHERE source_generation = ?
    200              ORDER BY source_sequence";
    201         #[cfg(test)]
    202         self.work.request(work::Read::Materialize, sql);
    203         let rows = sqlx::query(sql)
    204             .bind(self.generation.as_bytes().as_slice())
    205             .fetch_all(&self.pool)
    206             .await
    207             .map_err(map_backend)?;
    208         #[cfg(test)]
    209         self.work.returned(&rows);
    210         rows.iter().map(|row| self.decode_event_row(row)).collect()
    211     }
    212 
    213     fn visibility_for_rows(&self, rows: &[StoredEventRow]) -> Result<VisibilityEvaluation, Error> {
    214         #[cfg(test)]
    215         self.work.visibility(rows.len());
    216         evaluate_visibility(
    217             self.generation,
    218             rows.iter()
    219                 .map(|row| VisibilityInput::new(row.position, &row.event, row.stage)),
    220         )
    221     }
    222 
    223     fn validate_cursor(&self, query: &EventQuery) -> Result<(), Error> {
    224         if query
    225             .bounds()
    226             .cursor()
    227             .is_some_and(|cursor| cursor.generation() != self.generation)
    228         {
    229             return Err(Error::SourceGenerationChanged);
    230         }
    231         Ok(())
    232     }
    233 
    234     fn decode_event_row(&self, row: &sqlx::sqlite::SqliteRow) -> Result<StoredEventRow, Error> {
    235         let generation = source_generation(row.try_get("source_generation").map_err(map_corrupt)?)?;
    236         if generation != self.generation {
    237             return Err(Error::CorruptStoredEvent);
    238         }
    239         let sequence = event_sequence(row.try_get("source_sequence").map_err(map_corrupt)?)?;
    240         let raw_json = String::from_utf8(row.try_get("signed_event").map_err(map_corrupt)?)
    241             .map_err(|_| Error::CorruptStoredEvent)?;
    242         #[cfg(test)]
    243         self.work.decode(raw_json.len());
    244         let event =
    245             Codec::decode_signed_event(raw_json.as_str()).map_err(|_| Error::CorruptStoredEvent)?;
    246         #[cfg(test)]
    247         self.work.decoded();
    248         let stage = admission_stage(row.try_get("admission_stage").map_err(map_corrupt)?)?;
    249         let contract_id = row
    250             .try_get::<Option<String>, _>("admitted_contract_id")
    251             .map_err(map_corrupt)?;
    252         let registry_version = row
    253             .try_get::<Option<i64>, _>("admitted_registry_version")
    254             .map_err(map_corrupt)?
    255             .map(|value| u32::try_from(value).map_err(|_| Error::CorruptStoredEvent))
    256             .transpose()?;
    257         if contract_id.is_some() != registry_version.is_some()
    258             || registry_version.is_some_and(|version| {
    259                 version != radroots_event::contract::RegistryVersion::CURRENT.get()
    260             })
    261             || contract_id.as_deref().is_some_and(|stored| {
    262                 radroots_event::contract::registry_v7::validate_event_contract_for_admission(
    263                     event.envelope(),
    264                     stored,
    265                 )
    266                 .is_err()
    267             })
    268         {
    269             return Err(Error::CorruptStoredEvent);
    270         }
    271         Ok(StoredEventRow {
    272             position: EventPosition::new(generation, sequence),
    273             raw_json,
    274             event,
    275             stage,
    276         })
    277     }
    278 
    279     async fn store_provenance(
    280         transaction: &mut sqlx::Transaction<'_, Sqlite>,
    281         admission: &EventAdmission,
    282     ) -> Result<(), Error> {
    283         let provenance = admission.provenance();
    284         let cursor = provenance.cursor().map_or("", |cursor| cursor.as_str());
    285         sqlx::query(
    286             "INSERT OR IGNORE INTO radroots_runtime_event_provenance (
    287                event_id, transport_id, target_fingerprint, observed_at_unix_ms, cursor
    288              ) VALUES (?, ?, ?, ?, ?)",
    289         )
    290         .bind(admission.event_id().as_bytes().as_slice())
    291         .bind(provenance.transport_id().as_str())
    292         .bind(provenance.target().as_str())
    293         .bind(i64_from_u64(provenance.observed_at_unix_ms())?)
    294         .bind(cursor)
    295         .execute(&mut **transaction)
    296         .await
    297         .map_err(map_backend)?;
    298         Ok(())
    299     }
    300 
    301     pub(crate) async fn admit_transaction(
    302         &self,
    303         transaction: &mut sqlx::Transaction<'_, Sqlite>,
    304         admission: EventAdmission,
    305     ) -> Result<AdmissionReceipt, Error> {
    306         let index_was_ready = sqlx::query_scalar::<_, bool>(
    307             "SELECT ready FROM radroots_runtime_visibility_progress WHERE source_generation = ?",
    308         )
    309         .bind(self.generation.as_bytes().as_slice())
    310         .fetch_optional(&mut **transaction)
    311         .await
    312         .map_err(map_backend)?
    313         .unwrap_or(false);
    314         let existing = sqlx::query(
    315             "SELECT source_generation, source_sequence, signed_event, admission_stage,
    316                     admitted_contract_id, admitted_registry_version
    317              FROM radroots_runtime_events WHERE event_id = ?",
    318         )
    319         .bind(admission.event_id().as_bytes().as_slice())
    320         .fetch_optional(&mut **transaction)
    321         .await
    322         .map_err(map_backend)?;
    323 
    324         let (position, disposition) = if let Some(row) = existing {
    325             let stored = self.decode_event_row(&row)?;
    326             let metadata = admission_contract_metadata(&admission);
    327             if stored.raw_json.as_bytes() != admission.event().raw_json().as_bytes() {
    328                 return Err(Error::EventConflict);
    329             }
    330             if admission.stage() < stored.stage {
    331                 return Err(Error::AdmissionRegression);
    332             }
    333             let disposition = if admission.stage() == stored.stage {
    334                 AdmissionDisposition::Duplicate
    335             } else {
    336                 sqlx::query(
    337                     "UPDATE radroots_runtime_events
    338                      SET admission_stage = ?, updated_at_unix_ms = MAX(updated_at_unix_ms, ?),
    339                          admitted_contract_id = COALESCE(admitted_contract_id, ?),
    340                          admitted_registry_version = COALESCE(admitted_registry_version, ?)
    341                      WHERE event_id = ?",
    342                 )
    343                 .bind(stage_name(admission.stage()))
    344                 .bind(i64_from_u64(admission.provenance().observed_at_unix_ms())?)
    345                 .bind(metadata.map(|value| value.0))
    346                 .bind(metadata.map(|value| i64::from(value.1)))
    347                 .bind(admission.event_id().as_bytes().as_slice())
    348                 .execute(&mut **transaction)
    349                 .await
    350                 .map_err(map_backend)?;
    351                 AdmissionDisposition::Advanced
    352             };
    353             (stored.position, disposition)
    354         } else {
    355             let metadata = admission_contract_metadata(&admission);
    356             let next = sqlx::query_scalar::<_, i64>(
    357                 "UPDATE radroots_runtime_source_generations
    358                  SET sequence_head = sequence_head + 1
    359                  WHERE generation = ? AND state = 'active'
    360                  RETURNING sequence_head",
    361             )
    362             .bind(self.generation.as_bytes().as_slice())
    363             .fetch_optional(&mut **transaction)
    364             .await
    365             .map_err(map_backend)?
    366             .ok_or(Error::SourceGenerationChanged)?;
    367             let sequence = event_sequence(next)?;
    368             let observed_at = i64_from_u64(admission.provenance().observed_at_unix_ms())?;
    369             sqlx::query(
    370                 "INSERT INTO radroots_runtime_events (
    371                    source_generation, source_sequence, event_id, admission_stage,
    372                    signed_event, admitted_at_unix_ms, updated_at_unix_ms,
    373                    admitted_contract_id, admitted_registry_version
    374                  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
    375             )
    376             .bind(self.generation.as_bytes().as_slice())
    377             .bind(next)
    378             .bind(admission.event_id().as_bytes().as_slice())
    379             .bind(stage_name(admission.stage()))
    380             .bind(admission.event().raw_json().as_bytes())
    381             .bind(observed_at)
    382             .bind(observed_at)
    383             .bind(metadata.map(|value| value.0))
    384             .bind(metadata.map(|value| i64::from(value.1)))
    385             .execute(&mut **transaction)
    386             .await
    387             .map_err(map_backend)?;
    388             (
    389                 EventPosition::new(self.generation, sequence),
    390                 AdmissionDisposition::Inserted,
    391             )
    392         };
    393         Self::store_provenance(transaction, &admission).await?;
    394         let bounds = radroots_storage::event::VisibilityIndexBounds::new(64, 16 * 1024 * 1024)?;
    395         let bytes = u64::try_from(admission.event().raw_json().len())
    396             .map_err(|_| Error::SpaceInsufficient)?;
    397         let fits = radroots_storage::event::VisibilityIndexBounds::charge(bytes)?
    398             <= bounds.bytes() - 4096 - u64::from(bounds.rows()) * 128;
    399         if index_was_ready && disposition != AdmissionDisposition::Duplicate && fits {
    400             self.prepare_visibility_transaction(transaction, bounds)
    401                 .await?;
    402         }
    403         Ok(AdmissionReceipt::new(
    404             *admission.event_id(),
    405             position,
    406             admission.stage(),
    407             disposition,
    408         ))
    409     }
    410 }
    411 
    412 fn admission_contract_metadata(admission: &EventAdmission) -> Option<(&'static str, u32)> {
    413     admission.visible_event().map(|event| {
    414         (
    415             event.admitted_event().validated_event().contract_id(),
    416             radroots_event::contract::RegistryVersion::CURRENT.get(),
    417         )
    418     })
    419 }
    420 
    421 #[cfg_attr(coverage_nightly, coverage(off))]
    422 impl EventStore for SqliteStorage {
    423     fn maintain_visibility(
    424         &self,
    425         bounds: radroots_storage::event::VisibilityIndexBounds,
    426     ) -> BoxFuture<'_, Result<radroots_storage::event::VisibilityIndexProgress, Error>> {
    427         Box::pin(async move { self.prepare_visibility_index(bounds).await })
    428     }
    429 
    430     fn source_token(&self) -> BoxFuture<'_, Result<EventSourceToken, Error>> {
    431         Box::pin(async move {
    432             let epoch = sqlx::query_scalar::<_, i64>(
    433                 "SELECT mutation_epoch FROM radroots_runtime_source_generations
    434                  WHERE generation = ? AND state = 'active'",
    435             )
    436             .bind(self.generation.as_bytes().as_slice())
    437             .fetch_optional(&self.pool)
    438             .await
    439             .map_err(map_backend)?
    440             .ok_or(Error::SourceGenerationChanged)?;
    441             Ok(EventSourceToken::new(
    442                 self.generation,
    443                 u64::try_from(epoch).map_err(|_| Error::CorruptStoredEvent)?,
    444             ))
    445         })
    446     }
    447 
    448     fn status(&self) -> BoxFuture<'_, Result<EventStoreStatus, Error>> {
    449         Box::pin(async move {
    450             let mut transaction = self.pool.begin().await.map_err(map_backend)?;
    451             let status = self.visibility_header(&mut transaction, None).await?;
    452             transaction.commit().await.map_err(map_backend)?;
    453             Ok(status)
    454         })
    455     }
    456 
    457     fn admit(&self, admission: EventAdmission) -> BoxFuture<'_, Result<AdmissionReceipt, Error>> {
    458         Box::pin(async move {
    459             if self.mode == EventStoreMode::ReadOnly {
    460                 return Err(Error::BackendUnavailable);
    461             }
    462             let mut transaction = self
    463                 .pool
    464                 .begin_with("BEGIN IMMEDIATE")
    465                 .await
    466                 .map_err(map_backend)?;
    467             let receipt = self.admit_transaction(&mut transaction, admission).await?;
    468             transaction.commit().await.map_err(map_backend)?;
    469             Ok(receipt)
    470         })
    471     }
    472 
    473     fn query_raw(
    474         &self,
    475         query: EventQuery,
    476     ) -> BoxFuture<'_, Result<EventPage<StoredRawEvent>, Error>> {
    477         Box::pin(async move {
    478             let (rows, next) = self.selected(&query, AdmissionStage::Raw).await?;
    479             let items = rows
    480                 .into_iter()
    481                 .map(|row| StoredRawEvent::new(row.position, row.event, row.stage))
    482                 .collect();
    483             EventPage::new(self.generation, items, next, query.bounds())
    484         })
    485     }
    486 
    487     fn query_verified(
    488         &self,
    489         query: EventQuery,
    490     ) -> BoxFuture<'_, Result<EventPage<StoredVerifiedEvent>, Error>> {
    491         Box::pin(async move {
    492             let (rows, next) = self.selected(&query, AdmissionStage::Verified).await?;
    493             let items = rows
    494                 .into_iter()
    495                 .map(|row| StoredVerifiedEvent::new(row.position, row.event))
    496                 .collect();
    497             EventPage::new(self.generation, items, next, query.bounds())
    498         })
    499     }
    500 
    501     fn query_visible(
    502         &self,
    503         query: EventQuery,
    504     ) -> BoxFuture<'_, Result<EventPage<StoredVisibleEvent>, Error>> {
    505         Box::pin(async move { self.indexed_visible_page(query, None).await })
    506     }
    507 
    508     fn query_visible_at(
    509         &self,
    510         query: EventQuery,
    511         expected: EventSourceToken,
    512     ) -> BoxFuture<'_, Result<EventPage<StoredVisibleEvent>, Error>> {
    513         Box::pin(async move { self.indexed_visible_page(query, Some(expected)).await })
    514     }
    515 
    516     fn rebuild_visibility(&self) -> BoxFuture<'_, Result<VisibilitySnapshot, Error>> {
    517         Box::pin(async move {
    518             let rows = self.current_event_rows().await?;
    519             Ok(self.visibility_for_rows(&rows)?.into_snapshot())
    520         })
    521     }
    522 
    523     fn query_provenance(
    524         &self,
    525         event_id: EventId,
    526         bounds: EventQueryBounds,
    527     ) -> BoxFuture<'_, Result<EventPage<StoredEventProvenance>, Error>> {
    528         Box::pin(async move {
    529             if bounds
    530                 .cursor()
    531                 .is_some_and(|cursor| cursor.generation() != self.generation)
    532             {
    533                 return Err(Error::SourceGenerationChanged);
    534             }
    535             let event_row = sqlx::query(
    536                 "SELECT source_generation, source_sequence
    537                  FROM radroots_runtime_events WHERE event_id = ?",
    538             )
    539             .bind(event_id.as_bytes().as_slice())
    540             .fetch_optional(&self.pool)
    541             .await
    542             .map_err(map_backend)?
    543             .ok_or(Error::EventNotFound)?;
    544             let generation = source_generation(
    545                 event_row
    546                     .try_get("source_generation")
    547                     .map_err(map_corrupt)?,
    548             )?;
    549             if generation != self.generation {
    550                 return Err(Error::CorruptStoredEvent);
    551             }
    552             let position = EventPosition::new(
    553                 generation,
    554                 event_sequence(event_row.try_get("source_sequence").map_err(map_corrupt)?)?,
    555             );
    556             let after = bounds.cursor().map_or(0, |cursor| cursor.sequence().get());
    557             let items = if position.sequence().get() <= after {
    558                 Vec::new()
    559             } else {
    560                 let rows = sqlx::query(
    561                     "SELECT transport_id, target_fingerprint, observed_at_unix_ms, cursor
    562                      FROM radroots_runtime_event_provenance
    563                      WHERE event_id = ?
    564                      ORDER BY observed_at_unix_ms, transport_id, target_fingerprint, cursor
    565                      LIMIT ?",
    566                 )
    567                 .bind(event_id.as_bytes().as_slice())
    568                 .bind(i64::from(bounds.limit()))
    569                 .fetch_all(&self.pool)
    570                 .await
    571                 .map_err(map_backend)?;
    572                 rows.iter()
    573                     .map(|row| {
    574                         let cursor = row.try_get::<String, _>("cursor").map_err(map_corrupt)?;
    575                         StoredEventProvenance::from_stored_parts(
    576                             position,
    577                             row.try_get::<String, _>("transport_id")
    578                                 .map_err(map_corrupt)?
    579                                 .as_str(),
    580                             row.try_get::<String, _>("target_fingerprint")
    581                                 .map_err(map_corrupt)?
    582                                 .as_str(),
    583                             u64_from_i64(row.try_get("observed_at_unix_ms").map_err(map_corrupt)?)?,
    584                             (!cursor.is_empty()).then_some(cursor.as_str()),
    585                         )
    586                     })
    587                     .collect::<Result<Vec<_>, Error>>()?
    588             };
    589             EventPage::new(self.generation, items, None, bounds)
    590         })
    591     }
    592 }
    593 
    594 const fn stage_name(stage: AdmissionStage) -> &'static str {
    595     match stage {
    596         AdmissionStage::Raw => "raw",
    597         AdmissionStage::Verified => "verified",
    598         AdmissionStage::Visible => "visible",
    599     }
    600 }
    601 
    602 fn admission_stage(value: String) -> Result<AdmissionStage, Error> {
    603     match value.as_str() {
    604         "raw" => Ok(AdmissionStage::Raw),
    605         "verified" => Ok(AdmissionStage::Verified),
    606         "visible" => Ok(AdmissionStage::Visible),
    607         _ => Err(Error::CorruptStoredEvent),
    608     }
    609 }
    610 
    611 fn source_generation(value: Vec<u8>) -> Result<SourceGeneration, Error> {
    612     SourceGeneration::new(value.try_into().map_err(|_| Error::CorruptStoredEvent)?)
    613         .map_err(|_| Error::CorruptStoredEvent)
    614 }
    615 
    616 fn event_sequence(value: i64) -> Result<EventSequence, Error> {
    617     EventSequence::new(u64_from_i64(value)?).map_err(|_| Error::CorruptStoredEvent)
    618 }
    619 
    620 fn i64_from_u64(value: u64) -> Result<i64, Error> {
    621     i64::try_from(value).map_err(|_| Error::CorruptStoredEvent)
    622 }
    623 
    624 fn u64_from_i64(value: i64) -> Result<u64, Error> {
    625     u64::try_from(value).map_err(|_| Error::CorruptStoredEvent)
    626 }
    627 
    628 fn map_corrupt(_: sqlx::Error) -> Error {
    629     Error::CorruptStoredEvent
    630 }
    631 
    632 #[cfg(test)]
    633 mod mutation_tests;
    634 #[cfg(test)]
    635 mod work;
    636 #[cfg(test)]
    637 mod work_tests;
    638 
    639 #[cfg(test)]
    640 #[cfg_attr(coverage_nightly, coverage(off))]
    641 mod tests {
    642     use super::*;
    643     use crate::migration::runtime::{MIGRATIONS, migration_sql};
    644     use radroots_event::{
    645         SignedEvent,
    646         admission::{AdmissionPolicy, RawEvent, VisibilityPolicy, VisibleEvent},
    647         wire::Nip01EventWire,
    648     };
    649     use radroots_storage::event::EventQueryBounds;
    650     use radroots_transport::{
    651         Target, TransportId,
    652         source::{EventProvenance, FetchCursor, ObservedEvent},
    653     };
    654     use sqlx::sqlite::SqlitePoolOptions;
    655 
    656     struct Allow;
    657 
    658     impl radroots_event::admission::SignatureVerifier for Allow {
    659         fn verify_signature(
    660             &self,
    661             _event: &radroots_event::Event,
    662         ) -> Result<(), radroots_event::Error> {
    663             Ok(())
    664         }
    665     }
    666 
    667     impl AdmissionPolicy for Allow {
    668         type Error = core::convert::Infallible;
    669 
    670         fn policy_id(&self) -> &'static str {
    671             "test.storage-sqlite.admission.v1"
    672         }
    673 
    674         fn admit(
    675             &self,
    676             _event: &radroots_event::admission::ContractValidatedEvent,
    677         ) -> Result<(), Self::Error> {
    678             Ok(())
    679         }
    680     }
    681 
    682     impl VisibilityPolicy for Allow {
    683         type Error = core::convert::Infallible;
    684 
    685         fn policy_id(&self) -> &'static str {
    686             "test.storage-sqlite.visibility.v1"
    687         }
    688 
    689         fn make_visible(
    690             &self,
    691             _event: &radroots_event::admission::AdmittedEvent,
    692         ) -> Result<(), Self::Error> {
    693             Ok(())
    694         }
    695     }
    696 
    697     pub(super) async fn store(generation: SourceGeneration) -> SqliteStorage {
    698         let pool = SqlitePoolOptions::new()
    699             .max_connections(1)
    700             .connect("sqlite::memory:")
    701             .await
    702             .expect("memory SQLite");
    703         sqlx::query("PRAGMA foreign_keys = ON")
    704             .execute(&pool)
    705             .await
    706             .expect("foreign keys");
    707         for migration in MIGRATIONS {
    708             sqlx::raw_sql(migration_sql(migration.version()).expect("registered SQL"))
    709                 .execute(&pool)
    710                 .await
    711                 .expect("runtime migration");
    712         }
    713         sqlx::query(
    714             "INSERT INTO radroots_runtime_source_generations (
    715                generation, sequence_head, state, created_at_unix_ms, retired_at_unix_ms
    716              ) VALUES (?, 0, 'active', 1, NULL)",
    717         )
    718         .bind(generation.as_bytes().as_slice())
    719         .execute(&pool)
    720         .await
    721         .expect("source generation");
    722         let storage = SqliteStorage::new(pool, generation, EventStoreMode::ReadWrite);
    723         storage
    724             .maintain_visibility(
    725                 radroots_storage::event::VisibilityIndexBounds::new(64, 16 * 1024 * 1024).unwrap(),
    726             )
    727             .await
    728             .unwrap();
    729         storage
    730     }
    731 
    732     pub(super) async fn unprepared_store(generation: SourceGeneration) -> SqliteStorage {
    733         let storage = store(generation).await;
    734         sqlx::query("DELETE FROM radroots_runtime_visibility_progress WHERE source_generation = ?")
    735             .bind(generation.as_bytes().as_slice())
    736             .execute(&storage.pool)
    737             .await
    738             .unwrap();
    739         storage
    740     }
    741 
    742     fn signed_event(content: &str, pretty: bool) -> SignedEvent {
    743         signed_event_with(content, pretty, 1_800_000_100, 0, vec![])
    744     }
    745 
    746     pub(super) fn signed_event_with(
    747         content: &str,
    748         pretty: bool,
    749         created_at: u64,
    750         kind: u32,
    751         tags: Vec<Vec<String>>,
    752     ) -> SignedEvent {
    753         let mut wire = Nip01EventWire {
    754             id: "0".repeat(64),
    755             pubkey: "585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df".to_owned(),
    756             created_at,
    757             kind,
    758             tags,
    759             content: content.to_owned(),
    760             sig: "42".repeat(64),
    761             extra: Default::default(),
    762         };
    763         wire.id = wire
    764             .computed_event_id()
    765             .expect("canonical event id")
    766             .to_hex();
    767         let value = serde_json::json!({
    768             "id": &wire.id,
    769             "pubkey": &wire.pubkey,
    770             "created_at": wire.created_at,
    771             "kind": wire.kind,
    772             "tags": &wire.tags,
    773             "content": &wire.content,
    774             "sig": &wire.sig,
    775         });
    776         let raw_json = if pretty {
    777             serde_json::to_string_pretty(&value).expect("pretty event JSON")
    778         } else {
    779             value.to_string()
    780         };
    781         SignedEvent::from_wire_verified_id(wire, raw_json).expect("signed event")
    782     }
    783 
    784     pub(super) fn observed(event: SignedEvent, at: u64, cursor: Option<&str>) -> ObservedEvent {
    785         let target = Target::new(TransportId::NOSTR, "wss://relay.example").expect("target");
    786         let mut provenance =
    787             EventProvenance::new(TransportId::NOSTR, target.fingerprint().clone(), at)
    788                 .expect("provenance");
    789         if let Some(cursor) = cursor {
    790             provenance = provenance.with_cursor(FetchCursor::parse(cursor).expect("cursor"));
    791         }
    792         ObservedEvent::new(event, provenance)
    793     }
    794 
    795     pub(super) fn verified(event: &SignedEvent) -> radroots_event::VerifiedEvent {
    796         RawEvent::new(event.envelope().clone())
    797             .verify_id()
    798             .expect("event id")
    799             .verify_signature(&Allow)
    800             .expect("signature")
    801     }
    802 
    803     pub(super) fn visible(event: &SignedEvent) -> VisibleEvent {
    804         let verified = verified(event);
    805         let validated = if event.envelope().kind_u32() == 5 {
    806             verified
    807                 .validate_contract_for_admission("radroots.social.deletion_request.v1")
    808                 .expect("admission-selected contract")
    809         } else {
    810             verified.validate_contract().expect("contract")
    811         };
    812         validated
    813             .admit_with(&Allow)
    814             .expect("admission")
    815             .make_visible_with(&Allow)
    816             .expect("visibility")
    817     }
    818 
    819     #[tokio::test]
    820     async fn admission_is_idempotent_monotonic_and_conflict_safe() {
    821         let generation = SourceGeneration::new([7; 32]).expect("generation");
    822         let store = store(generation).await;
    823         let event = signed_event(
    824             "{\"display_name\":\"Moss Street Farm\",\"bot\":false}",
    825             false,
    826         );
    827 
    828         let inserted = store
    829             .admit(EventAdmission::raw(observed(event.clone(), 10, None)))
    830             .await
    831             .expect("insert raw");
    832         assert_eq!(inserted.disposition(), AdmissionDisposition::Inserted);
    833         assert_eq!(inserted.position().sequence().get(), 1);
    834 
    835         let advanced = store
    836             .admit(
    837                 EventAdmission::visible(
    838                     observed(event.clone(), 11, Some("relay-page-1")),
    839                     visible(&event),
    840                 )
    841                 .expect("visible admission"),
    842             )
    843             .await
    844             .expect("advance visible");
    845         assert_eq!(advanced.disposition(), AdmissionDisposition::Advanced);
    846         assert_eq!(advanced.position(), inserted.position());
    847         let metadata = sqlx::query(
    848             "SELECT admitted_contract_id, admitted_registry_version
    849              FROM radroots_runtime_events WHERE event_id = ?",
    850         )
    851         .bind(event.id().as_bytes().as_slice())
    852         .fetch_one(&store.pool)
    853         .await
    854         .expect("event contract metadata");
    855         assert_eq!(
    856             metadata.get::<String, _>("admitted_contract_id"),
    857             "radroots.profile.metadata.v1"
    858         );
    859         assert_eq!(metadata.get::<i64, _>("admitted_registry_version"), 7);
    860 
    861         let duplicate = store
    862             .admit(
    863                 EventAdmission::visible(
    864                     observed(event.clone(), 11, Some("relay-page-1")),
    865                     visible(&event),
    866                 )
    867                 .expect("visible admission"),
    868             )
    869             .await
    870             .expect("duplicate visible");
    871         assert_eq!(duplicate.disposition(), AdmissionDisposition::Duplicate);
    872         assert_eq!(
    873             store
    874                 .admit(EventAdmission::raw(observed(event.clone(), 12, None)))
    875                 .await,
    876             Err(Error::AdmissionRegression)
    877         );
    878 
    879         let same_id_different_bytes = signed_event(
    880             "{\"display_name\":\"Moss Street Farm\",\"bot\":false}",
    881             true,
    882         );
    883         assert_eq!(same_id_different_bytes.id(), event.id());
    884         assert_eq!(
    885             store
    886                 .admit(EventAdmission::raw(observed(
    887                     same_id_different_bytes,
    888                     13,
    889                     None,
    890                 )))
    891                 .await,
    892             Err(Error::EventConflict)
    893         );
    894     }
    895 
    896     #[tokio::test]
    897     async fn queries_preserve_stage_bounds_cursors_and_exact_provenance() {
    898         let generation = SourceGeneration::new([8; 32]).expect("generation");
    899         let store = store(generation).await;
    900         let empty_status = store.status().await.expect("empty status");
    901         assert_eq!(empty_status.raw_events(), 0);
    902         assert_eq!(empty_status.verified_events(), 0);
    903         assert_eq!(empty_status.visible_events(), 0);
    904         let raw_event = signed_event("raw", false);
    905         let visible_event =
    906             signed_event("{\"display_name\":\"Visible Farm\",\"bot\":false}", false);
    907         store
    908             .admit(EventAdmission::raw(observed(raw_event.clone(), 20, None)))
    909             .await
    910             .expect("raw event");
    911         store
    912             .admit(
    913                 EventAdmission::visible(
    914                     observed(visible_event.clone(), 21, Some("relay-page-2")),
    915                     visible(&visible_event),
    916                 )
    917                 .expect("visible admission"),
    918             )
    919             .await
    920             .expect("visible event");
    921 
    922         let first = store
    923             .query_raw(EventQuery::all(EventQueryBounds::first(1).expect("bounds")))
    924             .await
    925             .expect("first page");
    926         assert_eq!(first.items().len(), 1);
    927         assert_eq!(first.items()[0].event(), &raw_event);
    928         let next = first.next_cursor().expect("continuation cursor");
    929         let second = store
    930             .query_raw(EventQuery::all(
    931                 EventQueryBounds::first(1).expect("bounds").after(next),
    932             ))
    933             .await
    934             .expect("second page");
    935         assert_eq!(second.items()[0].event(), &visible_event);
    936         assert!(second.next_cursor().is_none());
    937 
    938         let verified_page = store
    939             .query_verified(EventQuery::all(
    940                 EventQueryBounds::first(10).expect("bounds"),
    941             ))
    942             .await
    943             .expect("verified page");
    944         assert_eq!(verified_page.items().len(), 1);
    945         assert_eq!(verified_page.items()[0].event(), &visible_event);
    946         let visible_page = store
    947             .query_visible(
    948                 EventQuery::for_ids(
    949                     EventQueryBounds::first(10).expect("bounds"),
    950                     vec![*visible_event.id()],
    951                 )
    952                 .expect("id query"),
    953             )
    954             .await
    955             .expect("visible page");
    956         assert_eq!(visible_page.items().len(), 1);
    957 
    958         let provenance = store
    959             .query_provenance(
    960                 *visible_event.id(),
    961                 EventQueryBounds::first(10).expect("bounds"),
    962             )
    963             .await
    964             .expect("provenance");
    965         assert_eq!(provenance.items().len(), 1);
    966         assert_eq!(provenance.items()[0].provenance().observed_at_unix_ms(), 21);
    967         assert_eq!(
    968             provenance.items()[0]
    969                 .provenance()
    970                 .cursor()
    971                 .expect("cursor")
    972                 .as_str(),
    973             "relay-page-2"
    974         );
    975 
    976         let status = store.status().await.expect("status");
    977         assert_eq!(status.raw_events(), 2);
    978         assert_eq!(status.verified_events(), 1);
    979         assert_eq!(status.visible_events(), 1);
    980         let foreign_cursor = EventPosition::new(
    981             SourceGeneration::new([9; 32]).expect("foreign generation"),
    982             EventSequence::new(1).expect("sequence"),
    983         );
    984         assert_eq!(
    985             store
    986                 .query_raw(EventQuery::all(
    987                     EventQueryBounds::first(1)
    988                         .expect("bounds")
    989                         .after(foreign_cursor),
    990                 ))
    991                 .await,
    992             Err(Error::SourceGenerationChanged)
    993         );
    994     }
    995 
    996     #[tokio::test]
    997     async fn verified_replacement_and_same_count_advance_match_memory_after_reopen() {
    998         let generation = SourceGeneration::new([19; 32]).unwrap();
    999         let store = store(generation).await;
   1000         let memory = radroots_storage::memory::MemoryStorage::new(generation);
   1001         let old = signed_event_with(
   1002             r#"{"display_name":"Old Farm","bot":false}"#,
   1003             false,
   1004             10,
   1005             0,
   1006             vec![],
   1007         );
   1008         let newer = signed_event_with("malformed profile", false, 20, 0, vec![]);
   1009         let admissions = [
   1010             EventAdmission::visible(observed(old.clone(), 10, None), visible(&old)).unwrap(),
   1011             EventAdmission::raw(observed(newer.clone(), 20, None)),
   1012             EventAdmission::verified(observed(newer.clone(), 20, None), verified(&newer)).unwrap(),
   1013         ];
   1014         let mut previous_digest = None;
   1015         for (index, admission) in admissions.into_iter().enumerate() {
   1016             assert_eq!(
   1017                 store.admit(admission.clone()).await.unwrap(),
   1018                 memory.admit(admission).await.unwrap()
   1019             );
   1020             let reopened =
   1021                 SqliteStorage::new(store.pool.clone(), generation, EventStoreMode::ReadWrite);
   1022             assert_eq!(
   1023                 reopened.source_token().await.unwrap(),
   1024                 memory.source_token().await.unwrap()
   1025             );
   1026             assert_eq!(
   1027                 reopened.source_token().await.unwrap().epoch(),
   1028                 index as u64 + 1
   1029             );
   1030             let snapshot = reopened.rebuild_visibility().await.unwrap();
   1031             assert_eq!(snapshot, memory.rebuild_visibility().await.unwrap());
   1032             let query = EventQuery::all(EventQueryBounds::first(10).unwrap());
   1033             assert_eq!(
   1034                 reopened.query_visible(query.clone()).await.unwrap(),
   1035                 memory.query_visible(query).await.unwrap()
   1036             );
   1037             if index == 2 {
   1038                 assert_ne!(previous_digest, Some(snapshot.digest()));
   1039                 assert!(snapshot.visible_event_ids().is_empty());
   1040                 assert_eq!(snapshot.current_heads()[0].event_id, *newer.id());
   1041                 assert_eq!(reopened.status().await.unwrap().raw_events(), 2);
   1042             } else {
   1043                 assert_eq!(snapshot.visible_event_ids(), &[*old.id()]);
   1044             }
   1045             previous_digest = Some(snapshot.digest());
   1046         }
   1047     }
   1048 
   1049     #[tokio::test]
   1050     async fn visibility_rebuild_survives_reopen_and_matches_current_head_deletion_queries() {
   1051         let generation = SourceGeneration::new([18; 32]).expect("generation");
   1052         let store = store(generation).await;
   1053         let old = signed_event_with(
   1054             r#"{"display_name":"Old Farm","bot":false}"#,
   1055             false,
   1056             1_800_000_100,
   1057             0,
   1058             vec![],
   1059         );
   1060         let current = signed_event_with(
   1061             r#"{"display_name":"Current Farm","bot":false}"#,
   1062             false,
   1063             1_800_000_200,
   1064             0,
   1065             vec![],
   1066         );
   1067         let deletion = signed_event_with(
   1068             "retired profile",
   1069             false,
   1070             1_800_000_300,
   1071             5,
   1072             vec![vec!["e".to_owned(), current.id().to_hex()]],
   1073         );
   1074         for (event, observed_at) in [
   1075             (old.clone(), 100),
   1076             (current.clone(), 200),
   1077             (deletion.clone(), 300),
   1078         ] {
   1079             store
   1080                 .admit(
   1081                     EventAdmission::visible(
   1082                         observed(event.clone(), observed_at, None),
   1083                         visible(&event),
   1084                     )
   1085                     .expect("visible admission"),
   1086                 )
   1087                 .await
   1088                 .expect("admit visible event");
   1089         }
   1090 
   1091         let before = store
   1092             .rebuild_visibility()
   1093             .await
   1094             .expect("visibility rebuild");
   1095         let reopened =
   1096             SqliteStorage::new(store.pool.clone(), generation, EventStoreMode::ReadWrite);
   1097         let after = reopened
   1098             .rebuild_visibility()
   1099             .await
   1100             .expect("reopened visibility rebuild");
   1101         assert_eq!(before, after);
   1102         assert_eq!(after.current_heads()[0].event_id, *current.id());
   1103         assert_eq!(after.visible_event_ids(), &[*deletion.id()]);
   1104         assert_eq!(after.suppressed_event_ids(), &[*current.id()]);
   1105         assert_eq!(after.superseded_event_ids(), &[*old.id()]);
   1106         let page = reopened
   1107             .query_visible(EventQuery::all(
   1108                 EventQueryBounds::first(10).expect("bounds"),
   1109             ))
   1110             .await
   1111             .expect("visible page");
   1112         assert_eq!(page.items().len(), 1);
   1113         assert_eq!(page.items()[0].event().id(), deletion.id());
   1114         assert_eq!(reopened.status().await.expect("status").visible_events(), 1);
   1115     }
   1116 
   1117     #[tokio::test]
   1118     async fn corrupt_rows_fail_closed_and_source_history_is_immutable() {
   1119         let generation = SourceGeneration::new([10; 32]).expect("generation");
   1120         let store = store(generation).await;
   1121         let event = signed_event(
   1122             "{\"display_name\":\"Corruption Probe\",\"bot\":false}",
   1123             false,
   1124         );
   1125         store
   1126             .admit(EventAdmission::raw(observed(event.clone(), 30, None)))
   1127             .await
   1128             .expect("event");
   1129 
   1130         let wrong_generation = SourceGeneration::new([11; 32]).expect("generation");
   1131         let mismatched_store = SqliteStorage::new(
   1132             store.pool.clone(),
   1133             wrong_generation,
   1134             EventStoreMode::ReadWrite,
   1135         );
   1136         assert_eq!(
   1137             mismatched_store
   1138                 .admit(EventAdmission::raw(observed(event, 31, None)))
   1139                 .await,
   1140             Err(Error::CorruptStoredEvent)
   1141         );
   1142 
   1143         assert!(
   1144             sqlx::query("DELETE FROM radroots_runtime_events")
   1145                 .execute(&store.pool)
   1146                 .await
   1147                 .is_err()
   1148         );
   1149         assert!(
   1150             sqlx::query("DELETE FROM radroots_runtime_source_generations")
   1151                 .execute(&store.pool)
   1152                 .await
   1153                 .is_err()
   1154         );
   1155         sqlx::query("DROP TRIGGER radroots_runtime_events_contract_metadata_guard")
   1156             .execute(&store.pool)
   1157             .await
   1158             .expect("drop metadata guard for corruption probe");
   1159         sqlx::query(
   1160             "UPDATE radroots_runtime_events
   1161              SET admitted_contract_id = 'radroots.social.geochat.v1'",
   1162         )
   1163         .execute(&store.pool)
   1164         .await
   1165         .expect("forge contract metadata");
   1166         assert_eq!(
   1167             store
   1168                 .query_raw(EventQuery::all(EventQueryBounds::first(1).expect("bounds"),))
   1169                 .await,
   1170             Err(Error::CorruptStoredEvent)
   1171         );
   1172         sqlx::query(
   1173             "UPDATE radroots_runtime_events
   1174              SET admitted_contract_id = 'radroots.social.geochat.v1',
   1175                  admitted_registry_version = 7",
   1176         )
   1177         .execute(&store.pool)
   1178         .await
   1179         .expect("forge mismatched selected contract");
   1180         assert_eq!(
   1181             store
   1182                 .query_raw(EventQuery::all(EventQueryBounds::first(1).expect("bounds"),))
   1183                 .await,
   1184             Err(Error::CorruptStoredEvent)
   1185         );
   1186         sqlx::query(
   1187             "UPDATE radroots_runtime_events
   1188              SET admitted_registry_version = 6",
   1189         )
   1190         .execute(&store.pool)
   1191         .await
   1192         .expect("forge registry version");
   1193         assert_eq!(
   1194             store
   1195                 .query_raw(EventQuery::all(EventQueryBounds::first(1).expect("bounds"),))
   1196                 .await,
   1197             Err(Error::CorruptStoredEvent)
   1198         );
   1199         sqlx::query("PRAGMA ignore_check_constraints = ON")
   1200             .execute(&store.pool)
   1201             .await
   1202             .expect("disable checks for corruption probe");
   1203         sqlx::query("UPDATE radroots_runtime_events SET admission_stage = 'corrupt'")
   1204             .execute(&store.pool)
   1205             .await
   1206             .expect("forge corrupt stage");
   1207         assert_eq!(
   1208             store
   1209                 .query_raw(EventQuery::all(EventQueryBounds::first(1).expect("bounds"),))
   1210                 .await,
   1211             Err(Error::CorruptStoredEvent)
   1212         );
   1213     }
   1214 }