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 }