lib

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

stock_delivery.rs (10591B)


      1 //! Original obtained outers and complete transport results share stock ownership.
      2 use super::*;
      3 use crate::session::commerce::AcceptanceSelection;
      4 use alloc::boxed::Box;
      5 use core::num::NonZeroU64;
      6 use radroots_domain::PublicKey;
      7 use radroots_storage::{command::PrivateEnvelopeCandidate, inventory::*};
      8 use radroots_transport::{DeliveryReceipt, SinkFailure};
      9 
     10 pub(in crate::session) struct DeliveryContext {
     11     pub selection: AcceptanceSelection,
     12     pub recipient: PublicKey,
     13     pub store: Shared<dyn InventoryStore>,
     14     pub proof: AttachmentProof,
     15     pub _lease: Shared<dyn HostBound>,
     16     pub rewrap: Option<StockRewrapAdmission>,
     17 }
     18 impl DeliveryContext {
     19     pub(super) fn error(&self, reason: OperationError) -> Error {
     20         Error::capture_pending(reason, OperationContext::retained(self.selection.operation))
     21     }
     22     pub(super) fn request(
     23         &self,
     24         observed: Option<NonZeroU64>,
     25     ) -> Result<StockEnvelopeRequest, OperationError> {
     26         StockEnvelopeRequest::new(
     27             self.selection.binding.clone(),
     28             self.selection.minimum,
     29             self.selection.operation,
     30             self.selection.digest,
     31             self.recipient,
     32             observed,
     33         )
     34     }
     35     pub(super) fn proof(&self) -> Result<AttachmentProof, OperationError> {
     36         self.proof
     37             .with_secret(|bytes| AttachmentProof::from_protected_input(bytes))
     38             .map_err(Into::into)
     39     }
     40 }
     41 pub(in crate::session) struct RetainedEnvelope {
     42     context: DeliveryContext,
     43     candidate: PrivateEnvelopeCandidate,
     44     observed: Option<NonZeroU64>,
     45     receipt: Mutex<Option<StockEnvelopeReceipt>>,
     46 }
     47 pub(in crate::session) struct RetainedDelivery {
     48     context: DeliveryContext,
     49     attempt: Box<StockDeliveryAttempt>,
     50     result: Result<DeliveryReceipt, SinkFailure>,
     51     observed: Option<NonZeroU64>,
     52     complete: Mutex<bool>,
     53 }
     54 impl Owner {
     55     pub(in crate::session) fn retain_envelope(
     56         &self,
     57         context: DeliveryContext,
     58         candidate: PrivateEnvelopeCandidate,
     59         observed: Option<NonZeroU64>,
     60     ) -> Shared<RetainedEnvelope> {
     61         let entry = Shared::new(RetainedEnvelope {
     62             context,
     63             candidate,
     64             observed,
     65             receipt: Mutex::new(None),
     66         });
     67         self.envelopes
     68             .lock()
     69             .unwrap_or_else(std::sync::PoisonError::into_inner)
     70             .push(entry.clone());
     71         entry
     72     }
     73     pub(in crate::session) async fn capture_envelope(
     74         &self,
     75         entry: &Shared<RetainedEnvelope>,
     76     ) -> crate::Result<StockEnvelopeReceipt> {
     77         let _serial = self.serial.lock().await;
     78         self.append_envelope(entry, false).await
     79     }
     80     async fn append_envelope(
     81         &self,
     82         entry: &Shared<RetainedEnvelope>,
     83         reconciling: bool,
     84     ) -> crate::Result<StockEnvelopeReceipt> {
     85         let c = &entry.context;
     86         if let Some(receipt) = *entry
     87             .receipt
     88             .lock()
     89             .unwrap_or_else(std::sync::PoisonError::into_inner)
     90         {
     91             return Ok(receipt);
     92         }
     93         let request = c.request(entry.observed).map_err(|e| c.error(e))?;
     94         let proof = c.proof().map_err(|e| c.error(e))?;
     95         let outcome = if let Some(admission) = c.rewrap {
     96             let request = StockRewrapRequest::new(
     97                 request.with_envelope(entry.candidate.event_id()),
     98                 admission.rewrap_id(),
     99             );
    100             if reconciling {
    101                 c.store
    102                     .reconcile_stock_rewrap(request, proof, &entry.candidate)
    103                     .await
    104             } else {
    105                 c.store
    106                     .capture_stock_rewrap(request, proof, &entry.candidate)
    107                     .await
    108             }
    109         } else if reconciling {
    110             c.store
    111                 .reconcile_stock_envelope(request, proof, &entry.candidate)
    112                 .await
    113         } else {
    114             c.store
    115                 .capture_stock_envelope(request, proof, &entry.candidate)
    116                 .await
    117         }
    118         .map_err(|e| c.error(e))?;
    119         let StockEnvelopeOutcome::Committed(receipt) = outcome else {
    120             return Err(c.error(OperationError::RecoveryRequired));
    121         };
    122         let anchor = receipt.attempt();
    123         if anchor.workspace_id() != c.selection.binding.input().workspace_id()
    124             || anchor.operation_id() != c.selection.operation
    125             || anchor.command_digest() != c.selection.digest
    126             || anchor.transaction_id().is_none()
    127             || receipt.recipient() != c.recipient
    128             || receipt.event_id() != entry.candidate.event_id()
    129             || receipt.digest() != entry.candidate.digest()
    130             || receipt.rewrap_admission_transaction_id()
    131                 != c.rewrap.map(|admission| admission.transaction_id())
    132             || receipt.checkpoint().authority() != c.selection.minimum.authority()
    133         {
    134             return Err(c.error(OperationError::RecoveryRequired));
    135         }
    136         *entry
    137             .receipt
    138             .lock()
    139             .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(*receipt);
    140         let removed = {
    141             let mut entries = self
    142                 .envelopes
    143                 .lock()
    144                 .unwrap_or_else(std::sync::PoisonError::into_inner);
    145             entries
    146                 .iter()
    147                 .position(|v| Shared::ptr_eq(v, entry))
    148                 .map(|i| entries.remove(i))
    149         };
    150         drop(removed);
    151         Ok(*receipt)
    152     }
    153     pub(in crate::session) fn retain_delivery(
    154         &self,
    155         context: DeliveryContext,
    156         attempt: Box<StockDeliveryAttempt>,
    157         result: Result<DeliveryReceipt, SinkFailure>,
    158         observed: Option<NonZeroU64>,
    159     ) -> Shared<RetainedDelivery> {
    160         // No descriptor conversion or storage call precedes registration. Even
    161         // malformed adapter reports retain the original result and byte lease.
    162         let entry = Shared::new(RetainedDelivery {
    163             context,
    164             attempt,
    165             result,
    166             observed,
    167             complete: Mutex::new(false),
    168         });
    169         self.deliveries
    170             .lock()
    171             .unwrap_or_else(std::sync::PoisonError::into_inner)
    172             .push(entry.clone());
    173         entry
    174     }
    175     pub(in crate::session) async fn capture_delivery(
    176         &self,
    177         entry: &Shared<RetainedDelivery>,
    178     ) -> crate::Result<()> {
    179         let _serial = self.serial.lock().await;
    180         self.append_delivery(entry, false).await
    181     }
    182     async fn append_delivery(
    183         &self,
    184         entry: &Shared<RetainedDelivery>,
    185         reconciling: bool,
    186     ) -> crate::Result<()> {
    187         let c = &entry.context;
    188         if *entry
    189             .complete
    190             .lock()
    191             .unwrap_or_else(std::sync::PoisonError::into_inner)
    192         {
    193             return Ok(());
    194         }
    195         let request = entry.attempt.transport_request().map_err(|e| c.error(e))?;
    196         let reports = match &entry.result {
    197             Ok(receipt) => {
    198                 receipt
    199                     .validate_for_request(&request)
    200                     .map_err(|_| c.error(OperationError::InvalidEvidence))?;
    201                 receipt.target_receipts()
    202             }
    203             Err(failure) => {
    204                 failure
    205                     .validate_for_request(&request)
    206                     .map_err(|_| c.error(OperationError::InvalidEvidence))?;
    207                 failure.partial_evidence()
    208             }
    209         };
    210         // Bound before allocating normalized copies and validate the entire
    211         // original result before the first write. Empty partial evidence stays
    212         // empty: a missing ACK never manufactures a target observation.
    213         let intent = entry.attempt.intent();
    214         if reports.len() > intent.targets().len()
    215             || reports.iter().any(|report| {
    216                 report.was_attempted()
    217                     && !intent.selection().contains(report.target().fingerprint())
    218             })
    219         {
    220             return Err(c.error(OperationError::InvalidEvidence));
    221         }
    222         let observations = reports
    223             .iter()
    224             .filter(|report| intent.selection().contains(report.target().fingerprint()))
    225             .map(|report| {
    226                 StockDeliveryObservation::from_store_report(&entry.attempt, report, entry.observed)
    227             })
    228             .collect::<Result<Vec<_>, _>>()
    229             .map_err(|e| c.error(e))?;
    230         for observation in &observations {
    231             let result = if reconciling {
    232                 c.store
    233                     .reconcile_stock_delivery_observation(
    234                         &c.selection.binding,
    235                         &c.proof,
    236                         observation,
    237                     )
    238                     .await
    239             } else {
    240                 c.store
    241                     .record_stock_delivery_observation(&c.selection.binding, &c.proof, observation)
    242                     .await
    243             }
    244             .map_err(|e| c.error(e))?;
    245             match result {
    246                 StockDeliveryObservationOutcome::Committed(receipt)
    247                     if receipt.observation() == observation => {}
    248                 _ => return Err(c.error(OperationError::RecoveryRequired)),
    249             }
    250         }
    251         *entry
    252             .complete
    253             .lock()
    254             .unwrap_or_else(std::sync::PoisonError::into_inner) = true;
    255         let removed = {
    256             let mut entries = self
    257                 .deliveries
    258                 .lock()
    259                 .unwrap_or_else(std::sync::PoisonError::into_inner);
    260             entries
    261                 .iter()
    262                 .position(|v| Shared::ptr_eq(v, entry))
    263                 .map(|i| entries.remove(i))
    264         };
    265         drop(removed);
    266         Ok(())
    267     }
    268     pub(super) async fn drain_delivery(&self) -> crate::Result<()> {
    269         self.drain_rewrap_admissions().await?;
    270         loop {
    271             let entry = self
    272                 .envelopes
    273                 .lock()
    274                 .unwrap_or_else(std::sync::PoisonError::into_inner)
    275                 .first()
    276                 .cloned();
    277             let Some(entry) = entry else { break };
    278             self.append_envelope(&entry, true).await?;
    279         }
    280         loop {
    281             let entry = self
    282                 .deliveries
    283                 .lock()
    284                 .unwrap_or_else(std::sync::PoisonError::into_inner)
    285                 .first()
    286                 .cloned();
    287             let Some(entry) = entry else { return Ok(()) };
    288             self.append_delivery(&entry, true).await?;
    289         }
    290     }
    291 }