lib

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

stock_evidence.rs (8644B)


      1 //! Retention of original obtained stock material across uncertain persistence.
      2 use super::{HostBound, Shared};
      3 use crate::{Error, OperationContext};
      4 use radroots_storage::{
      5     command::OperationError,
      6     inventory::{InventoryStore, StockEvidenceOutcome, StockEvidenceReceipt, StockEvidenceRequest},
      7     workspace::AttachmentProof,
      8 };
      9 use std::{sync::Mutex, vec::Vec};
     10 #[path = "stock_obtained.rs"]
     11 mod obtained;
     12 pub(super) use obtained::{ObtainedContext, RetainedObtained};
     13 #[path = "stock_unissued.rs"]
     14 mod unissued;
     15 pub(super) use unissued::RetainedUnissued;
     16 #[path = "stock_delivery.rs"]
     17 mod delivery;
     18 pub(super) use delivery::{DeliveryContext, RetainedDelivery, RetainedEnvelope};
     19 #[path = "stock_rewrap.rs"]
     20 mod rewrap;
     21 pub(super) use rewrap::RetainedAdmission;
     22 
     23 pub(super) struct Pending {
     24     store: Shared<dyn InventoryStore>,
     25     request: StockEvidenceRequest,
     26     proof: AttachmentProof,
     27     receipt: Mutex<Option<StockEvidenceReceipt>>,
     28     _lease: Shared<dyn HostBound>,
     29 }
     30 #[derive(Default)]
     31 pub(super) struct Owner {
     32     unmapped: Mutex<Vec<Shared<RetainedObtained>>>,
     33     pending: Mutex<Vec<Shared<Pending>>>,
     34     unissued: Mutex<Vec<Shared<RetainedUnissued>>>,
     35     envelopes: Mutex<Vec<Shared<RetainedEnvelope>>>,
     36     deliveries: Mutex<Vec<Shared<RetainedDelivery>>>,
     37     rewraps: Mutex<Vec<Shared<RetainedAdmission>>>,
     38     pub(super) delivery_serial: futures::lock::Mutex<()>,
     39     serial: futures::lock::Mutex<()>,
     40 }
     41 impl Owner {
     42     pub(super) fn ensure_ready(&self) -> Result<(), OperationError> {
     43         // Hold both views together: conversion inserts pending before removing
     44         // unmapped material, so a split observation must not miss that transfer.
     45         let pending = self
     46             .pending
     47             .lock()
     48             .unwrap_or_else(std::sync::PoisonError::into_inner);
     49         let unmapped = self
     50             .unmapped
     51             .lock()
     52             .unwrap_or_else(std::sync::PoisonError::into_inner);
     53         let unissued = self
     54             .unissued
     55             .lock()
     56             .unwrap_or_else(std::sync::PoisonError::into_inner);
     57         let envelopes = self
     58             .envelopes
     59             .lock()
     60             .unwrap_or_else(std::sync::PoisonError::into_inner);
     61         let deliveries = self
     62             .deliveries
     63             .lock()
     64             .unwrap_or_else(std::sync::PoisonError::into_inner);
     65         let rewraps = self
     66             .rewraps
     67             .lock()
     68             .unwrap_or_else(std::sync::PoisonError::into_inner);
     69         if pending.is_empty()
     70             && unmapped.is_empty()
     71             && unissued.is_empty()
     72             && envelopes.is_empty()
     73             && deliveries.is_empty()
     74             && rewraps.is_empty()
     75         {
     76             Ok(())
     77         } else {
     78             Err(OperationError::RecoveryRequired)
     79         }
     80     }
     81     pub(super) fn retain(
     82         &self,
     83         store: Shared<dyn InventoryStore>,
     84         request: StockEvidenceRequest,
     85         proof: AttachmentProof,
     86         lease: Shared<dyn HostBound>,
     87     ) -> Shared<Pending> {
     88         let entry = Shared::new(Pending {
     89             store,
     90             request,
     91             proof,
     92             receipt: Mutex::new(None),
     93             _lease: lease,
     94         });
     95         self.pending
     96             .lock()
     97             .unwrap_or_else(std::sync::PoisonError::into_inner)
     98             .push(entry.clone());
     99         entry
    100     }
    101     pub(super) async fn capture(
    102         &self,
    103         entry: &Shared<Pending>,
    104     ) -> crate::Result<StockEvidenceOutcome> {
    105         let _serial = self.serial.lock().await;
    106         self.append(entry, false).await
    107     }
    108     async fn append(
    109         &self,
    110         entry: &Shared<Pending>,
    111         reconciling: bool,
    112     ) -> crate::Result<StockEvidenceOutcome> {
    113         let error = |reason| {
    114             Error::capture_pending(
    115                 reason,
    116                 OperationContext::proposed(Some(entry.request.operation_id())),
    117             )
    118         };
    119         let committed = *entry
    120             .receipt
    121             .lock()
    122             .unwrap_or_else(std::sync::PoisonError::into_inner);
    123         if let Some(receipt) = committed {
    124             return Ok(StockEvidenceOutcome::Committed(receipt));
    125         }
    126         let outcome = if reconciling {
    127             entry
    128                 .store
    129                 .reconcile_stock_evidence(&entry.request, &entry.proof)
    130                 .await
    131         } else {
    132             entry
    133                 .store
    134                 .capture_stock_evidence(&entry.request, &entry.proof)
    135                 .await
    136         }
    137         .map_err(error)?;
    138         match outcome {
    139             StockEvidenceOutcome::Committed(receipt) => {
    140                 let anchor = receipt.attempt();
    141                 let original = entry.request.attempt();
    142                 // Host reports cannot redirect ownership to a different original.
    143                 // Actual authentication and durable append remain host obligations.
    144                 if anchor.workspace_id() != original.workspace_id()
    145                     || anchor.operation_id() != original.operation_id()
    146                     || anchor.command_digest() != original.command_digest()
    147                     || anchor.transaction_id().is_none()
    148                     || receipt.signing_attempt_id() != entry.request.signing_attempt_id()
    149                     || receipt.recipient() != entry.request.recipient()
    150                     || receipt.digest() != &entry.request.evidence_digest()
    151                 {
    152                     return Err(error(OperationError::RecoveryRequired));
    153                 }
    154                 *entry
    155                     .receipt
    156                     .lock()
    157                     .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(receipt);
    158                 let removed = {
    159                     let mut pending = self
    160                         .pending
    161                         .lock()
    162                         .unwrap_or_else(std::sync::PoisonError::into_inner);
    163                     pending
    164                         .iter()
    165                         .position(|value| Shared::ptr_eq(value, entry))
    166                         .map(|index| pending.remove(index))
    167                 };
    168                 drop(removed);
    169                 Ok(StockEvidenceOutcome::Committed(receipt))
    170             }
    171             StockEvidenceOutcome::Unknown(anchor) => {
    172                 let original = entry.request.attempt();
    173                 if anchor.workspace_id() != original.workspace_id()
    174                     || anchor.operation_id() != original.operation_id()
    175                     || anchor.command_digest() != original.command_digest()
    176                 {
    177                     return Err(error(OperationError::RecoveryRequired));
    178                 }
    179                 // Retain exact bytes, original credentials and the resource/byte
    180                 // lease. Neither an unknown result nor an error releases them.
    181                 Ok(StockEvidenceOutcome::Unknown(anchor))
    182             }
    183         }
    184     }
    185     pub(super) async fn drain(&self) -> crate::Result<()> {
    186         let _serial = self.serial.lock().await;
    187         loop {
    188             let entry = self
    189                 .unissued
    190                 .lock()
    191                 .unwrap_or_else(std::sync::PoisonError::into_inner)
    192                 .first()
    193                 .cloned();
    194             let Some(entry) = entry else { break };
    195             if matches!(
    196                 self.append_unissued(&entry, true).await?,
    197                 crate::session::commerce::AcceptanceUnissuedOutcome::Unknown(_)
    198             ) {
    199                 return Err(Error::capture_pending(
    200                     OperationError::RecoveryRequired,
    201                     OperationContext::retained(entry.operation()),
    202                 ));
    203             }
    204         }
    205         loop {
    206             let entry = self
    207                 .unmapped
    208                 .lock()
    209                 .unwrap_or_else(std::sync::PoisonError::into_inner)
    210                 .first()
    211                 .cloned();
    212             let Some(entry) = entry else { break };
    213             self.map_obtained(&entry)?;
    214         }
    215         loop {
    216             let entry = self
    217                 .pending
    218                 .lock()
    219                 .unwrap_or_else(std::sync::PoisonError::into_inner)
    220                 .first()
    221                 .cloned();
    222             let Some(entry) = entry else {
    223                 return self.drain_delivery().await;
    224             };
    225             if let StockEvidenceOutcome::Unknown(_) = self.append(&entry, true).await? {
    226                 return Err(Error::operation(
    227                     OperationError::RecoveryRequired,
    228                     OperationContext::proposed(Some(entry.request.operation_id())),
    229                 ));
    230             }
    231         }
    232     }
    233 }