source_provider.rs (4274B)
1 use super::*; 2 use radroots_secrets::{ 3 Error, 4 provider::{SecretCapabilities, SecretProvider}, 5 wrapping::{KeyWrapping, UnwrapRequest, WrapRequest, WrappedSecret}, 6 }; 7 use radroots_transport::source::BoxFuture; 8 9 /// Pause after real provider IO, before the worker can confirm the observed 10 /// rows. The other connection must remain able to write at this boundary. 11 struct PausedProvider { 12 inner: Arc<FileProvider>, 13 gate: PausedClock, 14 schema: std::sync::Mutex<Option<&'static str>>, 15 } 16 impl PausedProvider { 17 fn arm(&self, schema: &'static str) { 18 *self.schema.lock().unwrap() = Some(schema); 19 self.gate.arm(); 20 } 21 fn pause(&self, schema: &str) { 22 let selected = { 23 let mut armed = self.schema.lock().unwrap(); 24 if *armed == Some(schema) { 25 armed.take().is_some() 26 } else { 27 false 28 } 29 }; 30 if selected { 31 self.gate.now().unwrap(); 32 } 33 } 34 } 35 impl SecretProvider for PausedProvider { 36 fn backend_kind(&self) -> BackendKind { 37 self.inner.backend_kind() 38 } 39 fn capabilities(&self) -> SecretCapabilities { 40 self.inner.capabilities() 41 } 42 } 43 impl KeyWrapping for PausedProvider { 44 fn wrap<'a>(&'a self, request: WrapRequest<'a>) -> BoxFuture<'a, Result<WrappedSecret, Error>> { 45 self.inner.wrap(request) 46 } 47 fn unwrap<'a>( 48 &'a self, 49 request: UnwrapRequest<'a>, 50 ) -> BoxFuture<'a, Result<SecretMaterial, Error>> { 51 Box::pin(async move { 52 let result = self.inner.unwrap(request).await; 53 self.pause(request.context().payload_schema().as_str()); 54 result 55 }) 56 } 57 } 58 59 #[tokio::test] 60 async fn source_reads_recheck_original_rows_changed_during_actual_provider_io() { 61 for statement in [ 62 "UPDATE stock_source_parts SET protected=randomblob(length(protected)) WHERE role=0 AND part=0", 63 "UPDATE stock_source_records SET protected=randomblob(length(protected))", 64 "UPDATE stock_source_evidence SET transaction_id=zeroblob(32)", 65 ] { 66 let row = source_vector("request/peer"); 67 let f = Fixture::new(); 68 let (store, e, binding) = create_source(&f, &row, f.clock.clone()).await; 69 let min = source_minimum(&store, &e).await; 70 let original = capture(&e, &row).await; 71 let receipt = retained( 72 store 73 .retain_stock_source(binding.clone(), min, &original, e.proof()) 74 .await 75 .unwrap(), 76 ); 77 store.close().await.unwrap(); 78 let provider = Arc::new(PausedProvider { 79 inner: f.provider.clone(), 80 gate: PausedClock { 81 state: std::sync::Mutex::new((false, false, false)), 82 changed: std::sync::Condvar::new(), 83 }, 84 schema: std::sync::Mutex::new(None), 85 }); 86 let crypto = WorkspaceCrypto::new( 87 provider.clone(), 88 SecretRef::new( 89 f.reference.id().clone(), 90 f.reference.backend(), 91 f.reference.key_version(), 92 ), 93 SecretMaterial::from_slice(&[0x41; 32]).unwrap(), 94 AccessPolicy::standard(), 95 ) 96 .unwrap(); 97 let store = 98 NativeWorkspace::open_seller_stock(&f.path, e.input().clone(), crypto, f.clock.clone()) 99 .await 100 .unwrap(); 101 let mut conn = database(&f).await; 102 provider.arm("radroots.seller_stock.source_record.v1"); 103 let mut future = Box::pin(store.stock_source( 104 binding, 105 receipt.checkpoint(), 106 original.envelope_id(), 107 e.proof(), 108 )); 109 assert!(futures::poll!(future.as_mut()).is_pending()); 110 provider.gate.entered(); 111 // This actual write succeeds while the selected worker is awaiting 112 // provider IO; no SQLite transaction may span that IO. 113 sqlx::raw_sql(statement).execute(&mut conn).await.unwrap(); 114 provider.gate.release(); 115 assert!(matches!( 116 future.await, 117 Err(OperationError::RecoveryRequired) 118 )); 119 conn.close().await.unwrap(); 120 store.close().await.unwrap(); 121 } 122 }