lib

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

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 }