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 }