lib

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

stock_unissued.rs (4239B)


      1 //! Retain original invocation material before any fallible capture or await.
      2 use super::*;
      3 use crate::session::commerce::{
      4     AcceptanceClaim, AcceptanceSelection, AcceptanceUnissued, AcceptanceUnissuedOutcome,
      5     AcceptanceUnissuedReceipt,
      6 };
      7 use alloc::boxed::Box;
      8 use radroots_domain::PublicKey;
      9 
     10 pub(in crate::session) struct RetainedUnissued {
     11     selection: AcceptanceSelection,
     12     claim: AcceptanceClaim,
     13     recipient: PublicKey,
     14     observation: Box<dyn AcceptanceUnissued>,
     15     receipt: Mutex<Option<AcceptanceUnissuedReceipt>>,
     16     _lease: Shared<dyn HostBound>,
     17 }
     18 impl RetainedUnissued {
     19     pub(super) fn operation(&self) -> radroots_domain::OperationId {
     20         self.selection.operation
     21     }
     22 }
     23 impl Owner {
     24     pub(in crate::session) fn retain_unissued(
     25         &self,
     26         selection: AcceptanceSelection,
     27         claim: AcceptanceClaim,
     28         recipient: PublicKey,
     29         observation: Box<dyn AcceptanceUnissued>,
     30         lease: Shared<dyn HostBound>,
     31     ) -> Shared<RetainedUnissued> {
     32         let entry = Shared::new(RetainedUnissued {
     33             selection,
     34             claim,
     35             recipient,
     36             observation,
     37             receipt: Mutex::new(None),
     38             _lease: lease,
     39         });
     40         self.unissued
     41             .lock()
     42             .unwrap_or_else(std::sync::PoisonError::into_inner)
     43             .push(entry.clone());
     44         entry
     45     }
     46     pub(in crate::session) async fn capture_unissued(
     47         &self,
     48         entry: &Shared<RetainedUnissued>,
     49     ) -> crate::Result<AcceptanceUnissuedOutcome> {
     50         let _serial = self.serial.lock().await;
     51         self.append_unissued(entry, false).await
     52     }
     53     pub(super) async fn append_unissued(
     54         &self,
     55         entry: &Shared<RetainedUnissued>,
     56         reconciling: bool,
     57     ) -> crate::Result<AcceptanceUnissuedOutcome> {
     58         let error = |reason| {
     59             Error::capture_pending(
     60                 reason,
     61                 OperationContext::retained(entry.selection.operation),
     62             )
     63         };
     64         let committed = *entry
     65             .receipt
     66             .lock()
     67             .unwrap_or_else(std::sync::PoisonError::into_inner);
     68         if let Some(receipt) = committed {
     69             return Ok(AcceptanceUnissuedOutcome::Committed(Box::new(receipt)));
     70         }
     71         // A malformed report must never cause material to leave this owner.
     72         if entry.observation.claim() != entry.claim {
     73             return Err(error(OperationError::RecoveryRequired));
     74         }
     75         let outcome = if reconciling {
     76             entry.observation.reconcile().await
     77         } else {
     78             entry.observation.capture().await
     79         }
     80         .map_err(error)?;
     81         let attempt = match &outcome {
     82             AcceptanceUnissuedOutcome::Committed(value) => value.attempt,
     83             AcceptanceUnissuedOutcome::Unknown(value) => *value,
     84         };
     85         if attempt.workspace_id() != entry.selection.binding.input().workspace_id()
     86             || attempt.operation_id() != entry.selection.operation
     87             || attempt.command_digest() != entry.selection.digest
     88         {
     89             return Err(error(OperationError::RecoveryRequired));
     90         }
     91         if let AcceptanceUnissuedOutcome::Committed(value) = &outcome {
     92             if attempt.transaction_id().is_none()
     93                 || value.claim != entry.claim.id
     94                 || value.recipient != entry.recipient
     95                 || value.reason != entry.observation.reason()
     96                 || value.checkpoint.authority() != entry.selection.minimum.authority()
     97             {
     98                 return Err(error(OperationError::RecoveryRequired));
     99             }
    100             *entry
    101                 .receipt
    102                 .lock()
    103                 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(**value);
    104             let removed = {
    105                 let mut pending = self
    106                     .unissued
    107                     .lock()
    108                     .unwrap_or_else(std::sync::PoisonError::into_inner);
    109                 pending
    110                     .iter()
    111                     .position(|v| Shared::ptr_eq(v, entry))
    112                     .map(|i| pending.remove(i))
    113             };
    114             drop(removed);
    115         }
    116         Ok(outcome)
    117     }
    118 }