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 }