lib

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

workspace_evidence.rs (18929B)


      1 //! Controlled owner/lifecycle tests, not signature or SQLite qualification.
      2 use super::*;
      3 use std::sync::atomic::AtomicUsize;
      4 
      5 #[derive(Default)]
      6 pub(super) struct Control {
      7     pub(super) reconciliations: AtomicUsize,
      8     pub(super) queries: AtomicUsize,
      9     mode: AtomicUsize,
     10     calls: Mutex<Vec<(OperationId, CommandDigest, SigningAttemptId, String)>>,
     11 }
     12 pub(super) fn capture<'a>(
     13     store: &'a Store,
     14     request: &'a StockEvidenceRequest,
     15     credential: &'a AttachmentProof,
     16 ) -> radroots_storage::event::BoxFuture<'a, Result<StockEvidenceOutcome, OperationError>> {
     17     Box::pin(async move {
     18         assert_eq!(credential.with_secret(|value| *value), [7; 32]);
     19         assert_eq!(request.binding().input(), &input(5));
     20         store.capture.calls.lock().unwrap().push((
     21             request.operation_id(),
     22             request.command_digest(),
     23             request.signing_attempt_id(),
     24             request.with_json(str::to_owned),
     25         ));
     26         poll_fn(|cx| {
     27             store.waker.register(cx.waker());
     28             if store.waiting.load(Ordering::SeqCst) {
     29                 Poll::Pending
     30             } else {
     31                 Poll::Ready(())
     32             }
     33         })
     34         .await;
     35         let mode = store.capture.mode.load(Ordering::SeqCst);
     36         let original = request.attempt();
     37         if mode == 2 {
     38             return Err(OperationError::StorageFailure);
     39         }
     40         if mode == 0 {
     41             return Ok(StockEvidenceOutcome::Unknown(original));
     42         }
     43         let anchor = radroots_storage::command::CommitAttempt::new(
     44             original.workspace_id(),
     45             if mode == 3 || mode == 4 {
     46                 OperationId::from_bytes([123; 32])
     47             } else {
     48                 original.operation_id()
     49             },
     50             original.command_digest(),
     51             Some(TransactionId::from_bytes([124; 32])),
     52         );
     53         if mode == 4 {
     54             return Ok(StockEvidenceOutcome::Unknown(anchor));
     55         }
     56         let receipt = StockEvidenceReceipt::from_committed_store(
     57             anchor,
     58             if mode == 6 {
     59                 SigningAttemptId::from_bytes([125; 32])
     60             } else {
     61                 request.signing_attempt_id()
     62             },
     63             request.recipient(),
     64             if mode == 5 {
     65                 [126; 32]
     66             } else {
     67                 request.evidence_digest()
     68             },
     69             request.observed_at_unix_ms(),
     70         )?;
     71         Ok(StockEvidenceOutcome::Committed(receipt))
     72     })
     73 }
     74 fn selected_store() -> Shared<Store> {
     75     let store = store();
     76     *store.model.binding.lock().unwrap() = WorkspaceBinding::from_authenticated_host(
     77         input(5),
     78         radroots_storage::workspace::WorkspaceScope::SellerStockOwner,
     79         ActorRef::new(key(), ActorRole::Seller, None, Some(input(5).grant_id())),
     80         "device",
     81         Sequence::new(1).unwrap(),
     82         UnixSeconds::new(200).unwrap(),
     83         UnixSeconds::new(100).unwrap(),
     84     )
     85     .unwrap();
     86     store
     87 }
     88 fn request(scope: &WorkspaceSession, op: u8) -> StockEvidenceRequest {
     89     StockEvidenceRequest::from_obtained_wire(
     90         scope.binding().clone(),
     91         OperationId::from_bytes([op; 32]),
     92         digest(),
     93         SigningAttemptId::from_bytes([83; 32]),
     94         key(),
     95         [84; 32],
     96         "synthetic retained material; this controlled port authenticates no signature",
     97         None,
     98     )
     99     .unwrap()
    100 }
    101 fn creation() -> radroots_protocol::command::CreatePoolInput {
    102     use radroots_domain::{listing::MeasurementUnit, stock::PoolUnit};
    103     radroots_protocol::command::CreatePoolInput::new(
    104         PoolId::from_bytes([85; 32]),
    105         "synthetic inventory",
    106         PoolUnit::new(MeasurementUnit::Each, 0).unwrap(),
    107         Quantity::new("1".parse().unwrap(), MeasurementUnit::Each).unwrap(),
    108     )
    109     .unwrap()
    110 }
    111 fn context(scope: &WorkspaceSession) -> radroots_execution::workspace::CommandContext {
    112     scope
    113         .command_context(
    114             OperationId::from_bytes([86; 32]),
    115             None,
    116             None,
    117             UnixSeconds::new(150).unwrap(),
    118         )
    119         .unwrap()
    120 }
    121 #[derive(Clone)]
    122 struct Lifecycle(Shared<Mutex<Vec<&'static str>>>, Option<Shared<Tasks>>);
    123 impl Lifecycle {
    124     fn record(&self, event: &'static str) -> HostFuture<'_, radroots_execution::Result<()>> {
    125         Box::pin(async move {
    126             self.0.lock().unwrap().push(event);
    127             Ok(())
    128         })
    129     }
    130 }
    131 impl SessionHost for Lifecycle {
    132     fn start(&self) -> HostFuture<'_, radroots_execution::Result<()>> {
    133         self.record("start")
    134     }
    135     fn quiesce(&self) -> HostFuture<'_, radroots_execution::Result<()>> {
    136         self.record("quiesce")
    137     }
    138     fn drain(&self) -> HostFuture<'_, radroots_execution::Result<()>> {
    139         Box::pin(async move {
    140             self.0.lock().unwrap().push("drain");
    141             if let Some(tasks) = &self.1 {
    142                 let jobs = core::mem::take(&mut *tasks.queued.lock().unwrap());
    143                 for job in jobs {
    144                     job.await;
    145                 }
    146             }
    147             Ok(())
    148         })
    149     }
    150     fn disconnect(&self) -> HostFuture<'_, radroots_execution::Result<()>> {
    151         self.record("disconnect")
    152     }
    153     fn dispose_callbacks(&self) -> HostFuture<'_, radroots_execution::Result<()>> {
    154         self.record("callbacks")
    155     }
    156     fn close_storage(&self) -> HostFuture<'_, radroots_execution::Result<()>> {
    157         self.record("storage")
    158     }
    159 }
    160 
    161 #[test]
    162 fn unknown_capture_retains_material_after_observer_loss_blocks_fresh_work_and_closes_only_after_exact_retry()
    163  {
    164     block_on(async {
    165         let store = selected_store();
    166         let tasks = Shared::new(Tasks::default());
    167         let trace = Shared::new(Mutex::new(Vec::new()));
    168         let client = ClientSession::new_with_task_host(
    169             Lifecycle(trace.clone(), None),
    170             core::num::NonZeroU16::new(8).unwrap(),
    171             tasks.clone(),
    172         );
    173         let scope = client
    174             .attach_workspace(store.clone(), input(5), proof())
    175             .await
    176             .unwrap();
    177         client.start().await.unwrap();
    178         let original = request(&scope, 90);
    179         let original_wire = original.with_json(str::to_owned);
    180         let mut observed =
    181             Box::pin(client.capture_stock_evidence(store.clone(), &scope, &original));
    182         assert!(futures::poll!(observed.as_mut()).is_pending());
    183         // A mutation admitted earlier must recheck before its actual store call.
    184         let mut queued_mutation = Box::pin(client.create_stock_pool(
    185             store.clone(),
    186             &scope,
    187             context(&scope),
    188             minimum(&scope),
    189             creation(),
    190         ));
    191         assert!(futures::poll!(queued_mutation.as_mut()).is_pending());
    192         assert_eq!(
    193             client
    194                 .capture_stock_evidence(store.clone(), &scope, &original)
    195                 .await
    196                 .unwrap_err()
    197                 .code(),
    198             Code::CapabilityUnavailable
    199         );
    200         drop(observed);
    201         drop(original);
    202         let jobs = core::mem::take(&mut *tasks.queued.lock().unwrap());
    203         for job in jobs {
    204             job.await;
    205         }
    206         assert_eq!(
    207             queued_mutation.await.unwrap_err().code(),
    208             Code::RecoveryRequired
    209         );
    210         assert_eq!(
    211             client
    212                 .create_stock_pool(
    213                     store.clone(),
    214                     &scope,
    215                     context(&scope),
    216                     minimum(&scope),
    217                     creation()
    218                 )
    219                 .await
    220                 .unwrap_err()
    221                 .code(),
    222             Code::RecoveryRequired
    223         );
    224         assert!(store.calls.lock().unwrap().is_empty());
    225         let mut read = Box::pin(client.stock_pool(
    226             store.clone(),
    227             &scope,
    228             minimum(&scope),
    229             PoolId::from_bytes([85; 32]),
    230         ));
    231         assert!(futures::poll!(read.as_mut()).is_pending());
    232         let job = tasks.queued.lock().unwrap().pop().unwrap();
    233         job.await;
    234         assert!(read.await.unwrap().is_none());
    235         assert_eq!(store.capture.queries.load(Ordering::SeqCst), 1);
    236         assert_eq!(
    237             client.close().await.unwrap_err().code(),
    238             Code::RecoveryRequired
    239         );
    240         assert_eq!(*trace.lock().unwrap(), vec!["start", "quiesce", "drain"]);
    241         store.capture.mode.store(1, Ordering::SeqCst);
    242         client.close().await.unwrap();
    243         assert_eq!(
    244             *trace.lock().unwrap(),
    245             vec![
    246                 "start",
    247                 "quiesce",
    248                 "drain",
    249                 "disconnect",
    250                 "callbacks",
    251                 "storage"
    252             ]
    253         );
    254         let calls = store.capture.calls.lock().unwrap();
    255         assert!(calls.len() >= 3);
    256         assert!(store.capture.reconciliations.load(Ordering::SeqCst) >= 2);
    257         assert!(calls.iter().all(|value| value == &calls[0]));
    258         assert_eq!(calls[0].0, OperationId::from_bytes([90; 32]));
    259         assert_eq!(calls[0].3, original_wire);
    260     });
    261 }
    262 
    263 #[test]
    264 fn storage_errors_and_foreign_receipts_keep_original_capture_until_a_matching_confirmed_append() {
    265     block_on(async {
    266         let store = selected_store();
    267         let tasks = Shared::new(Tasks::default());
    268         let client = ClientSession::new_with_task_host(
    269             Host,
    270             core::num::NonZeroU16::new(8).unwrap(),
    271             tasks.clone(),
    272         );
    273         let scope = client
    274             .attach_workspace(store.clone(), input(5), proof())
    275             .await
    276             .unwrap();
    277         client.start().await.unwrap();
    278         let original = request(&scope, 91);
    279         let mut observed =
    280             Box::pin(client.capture_stock_evidence(store.clone(), &scope, &original));
    281         assert!(futures::poll!(observed.as_mut()).is_pending());
    282         let job = tasks.queued.lock().unwrap().pop().unwrap();
    283         job.await;
    284         assert!(matches!(
    285             observed.await.unwrap(),
    286             StockEvidenceOutcome::Unknown(_)
    287         ));
    288         for mode in 2..=6 {
    289             store.capture.mode.store(mode, Ordering::SeqCst);
    290             let error = client.drain_stock_evidence().await.unwrap_err();
    291             assert_eq!(
    292                 error.code(),
    293                 if mode == 2 {
    294                     Code::StorageFailure
    295                 } else {
    296                     Code::RecoveryRequired
    297                 }
    298             );
    299             assert_eq!(error.retry(), RetryClass::ManualReconciliation);
    300             assert_eq!(
    301                 client
    302                     .create_stock_pool(
    303                         store.clone(),
    304                         &scope,
    305                         context(&scope),
    306                         minimum(&scope),
    307                         creation()
    308                     )
    309                     .await
    310                     .unwrap_err()
    311                     .code(),
    312                 Code::RecoveryRequired
    313             );
    314         }
    315         store.capture.mode.store(1, Ordering::SeqCst);
    316         client.drain_stock_evidence().await.unwrap();
    317         assert_eq!(store.capture.reconciliations.load(Ordering::SeqCst), 6);
    318         {
    319             let calls = store.capture.calls.lock().unwrap();
    320             assert!(calls.iter().all(|value| value == &calls[0]));
    321         }
    322         client.close().await.unwrap();
    323         original.with_json(|raw| assert!(raw.contains("synthetic retained material")));
    324     });
    325 }
    326 
    327 #[test]
    328 fn unpolled_foreign_closed_missing_and_refused_hosts_leave_original_input_and_execute_no_capture() {
    329     block_on(async {
    330         let store = selected_store();
    331         let tasks = Shared::new(Tasks::default());
    332         let client = ClientSession::new_with_task_host(
    333             Host,
    334             core::num::NonZeroU16::new(8).unwrap(),
    335             tasks.clone(),
    336         );
    337         let scope = client
    338             .attach_workspace(store.clone(), input(5), proof())
    339             .await
    340             .unwrap();
    341         client.start().await.unwrap();
    342         let original = request(&scope, 92);
    343         drop(client.capture_stock_evidence(store.clone(), &scope, &original));
    344         assert!(tasks.queued.lock().unwrap().is_empty());
    345         let foreign = WorkspaceSession::attach(store.clone(), input(5), proof())
    346             .await
    347             .unwrap();
    348         assert_eq!(
    349             client
    350                 .capture_stock_evidence(store.clone(), &foreign, &original)
    351                 .await
    352                 .unwrap_err()
    353                 .code(),
    354             Code::Unauthorized
    355         );
    356         for selected in [
    357             input(9),
    358             radroots_storage::workspace::seller_stock::SellerAuthoritySelection::from_attachment(
    359                 &input(5),
    360             )
    361             .attachment(GrantId::from_bytes([99; 32]))
    362             .unwrap(),
    363         ] {
    364             let actor = ActorRef::new(key(), ActorRole::Seller, None, Some(selected.grant_id()));
    365             let binding = WorkspaceBinding::from_authenticated_host(
    366                 selected,
    367                 radroots_storage::workspace::WorkspaceScope::SellerStockOwner,
    368                 actor,
    369                 "device",
    370                 Sequence::new(1).unwrap(),
    371                 UnixSeconds::new(200).unwrap(),
    372                 UnixSeconds::new(100).unwrap(),
    373             )
    374             .unwrap();
    375             let forged = StockEvidenceRequest::from_obtained_wire(
    376                 binding,
    377                 original.operation_id(),
    378                 original.command_digest(),
    379                 original.signing_attempt_id(),
    380                 original.recipient(),
    381                 *original.intent_digest(),
    382                 "synthetic foreign descriptor",
    383                 None,
    384             )
    385             .unwrap();
    386             assert_eq!(
    387                 client
    388                     .capture_stock_evidence(store.clone(), &scope, &forged)
    389                     .await
    390                     .unwrap_err()
    391                     .code(),
    392                 Code::Unauthorized
    393             );
    394         }
    395         tasks.refuse.store(true, Ordering::SeqCst);
    396         assert_eq!(
    397             client
    398                 .capture_stock_evidence(store.clone(), &scope, &original)
    399                 .await
    400                 .unwrap_err()
    401                 .code(),
    402             Code::CapabilityUnavailable
    403         );
    404         tasks.refuse.store(false, Ordering::SeqCst);
    405         scope.close();
    406         assert!(
    407             client
    408                 .capture_stock_evidence(store.clone(), &scope, &original)
    409                 .await
    410                 .is_err()
    411         );
    412         client.close().await.unwrap();
    413         let no_host = ClientSession::new(Host, core::num::NonZeroU16::new(8).unwrap());
    414         let scope = no_host
    415             .attach_workspace(store.clone(), input(5), proof())
    416             .await
    417             .unwrap();
    418         no_host.start().await.unwrap();
    419         assert!(
    420             no_host
    421                 .capture_stock_evidence(store.clone(), &scope, &original)
    422                 .await
    423                 .is_err()
    424         );
    425         no_host.close().await.unwrap();
    426         assert!(store.capture.calls.lock().unwrap().is_empty());
    427         original.with_json(|raw| assert!(raw.contains("synthetic retained material")));
    428     });
    429 }
    430 
    431 #[test]
    432 fn close_waits_for_the_active_capture_and_keeps_original_material_after_the_observer_is_dropped() {
    433     block_on(async {
    434         let store = selected_store();
    435         store.capture.mode.store(1, Ordering::SeqCst);
    436         store.waiting.store(true, Ordering::SeqCst);
    437         let tasks = Shared::new(Tasks::default());
    438         let trace = Shared::new(Mutex::new(Vec::new()));
    439         let client = ClientSession::new_with_task_host(
    440             Lifecycle(trace.clone(), None),
    441             core::num::NonZeroU16::new(8).unwrap(),
    442             tasks.clone(),
    443         );
    444         let scope = client
    445             .attach_workspace(store.clone(), input(5), proof())
    446             .await
    447             .unwrap();
    448         client.start().await.unwrap();
    449         let original = request(&scope, 93);
    450         let mut observed =
    451             Box::pin(client.capture_stock_evidence(store.clone(), &scope, &original));
    452         assert!(futures::poll!(observed.as_mut()).is_pending());
    453         let mut job = tasks.queued.lock().unwrap().pop().unwrap();
    454         assert!(futures::poll!(job.as_mut()).is_pending());
    455         drop(observed);
    456         drop(original);
    457         let mut closing = Box::pin(client.close());
    458         assert!(futures::poll!(closing.as_mut()).is_pending());
    459         assert_eq!(*trace.lock().unwrap(), vec!["start", "quiesce", "drain"]);
    460         store.waiting.store(false, Ordering::SeqCst);
    461         store.waker.wake();
    462         job.await;
    463         closing.await.unwrap();
    464         assert_eq!(
    465             *trace.lock().unwrap(),
    466             vec![
    467                 "start",
    468                 "quiesce",
    469                 "drain",
    470                 "disconnect",
    471                 "callbacks",
    472                 "storage"
    473             ]
    474         );
    475         assert_eq!(store.capture.calls.lock().unwrap().len(), 1);
    476     });
    477 }
    478 
    479 #[test]
    480 fn close_drives_the_host_owned_active_task_before_retrying_its_retained_capture() {
    481     block_on(async {
    482         let store = selected_store();
    483         store.capture.mode.store(1, Ordering::SeqCst);
    484         store.waiting.store(true, Ordering::SeqCst);
    485         let tasks = Shared::new(Tasks::default());
    486         let trace = Shared::new(Mutex::new(Vec::new()));
    487         let client = ClientSession::new_with_task_host(
    488             Lifecycle(trace.clone(), Some(tasks.clone())),
    489             core::num::NonZeroU16::new(8).unwrap(),
    490             tasks.clone(),
    491         );
    492         let scope = client
    493             .attach_workspace(store.clone(), input(5), proof())
    494             .await
    495             .unwrap();
    496         client.start().await.unwrap();
    497         let original = request(&scope, 94);
    498         let mut observed =
    499             Box::pin(client.capture_stock_evidence(store.clone(), &scope, &original));
    500         assert!(futures::poll!(observed.as_mut()).is_pending());
    501         let mut job = tasks.queued.lock().unwrap().pop().unwrap();
    502         assert!(futures::poll!(job.as_mut()).is_pending());
    503         tasks.queued.lock().unwrap().push(job);
    504         drop(observed);
    505         drop(original);
    506         let mut closing = Box::pin(client.close());
    507         assert!(futures::poll!(closing.as_mut()).is_pending());
    508         assert_eq!(*trace.lock().unwrap(), vec!["start", "quiesce", "drain"]);
    509         store.waiting.store(false, Ordering::SeqCst);
    510         store.waker.wake();
    511         assert!(matches!(
    512             futures::poll!(closing.as_mut()),
    513             Poll::Ready(Ok(()))
    514         ));
    515         assert_eq!(
    516             *trace.lock().unwrap(),
    517             vec![
    518                 "start",
    519                 "quiesce",
    520                 "drain",
    521                 "disconnect",
    522                 "callbacks",
    523                 "storage"
    524             ]
    525         );
    526         assert_eq!(store.capture.calls.lock().unwrap().len(), 1);
    527     });
    528 }