observation_operations.rs (7451B)
1 use super::{Selection, codec, observation}; 2 use crate::workspace::{ 3 BrowserWorkspace, WorkspaceError, 4 journal::{self, OperationChange}, 5 owned, 6 }; 7 use radroots_domain::{CommandDigest, OperationId}; 8 use radroots_storage::{ 9 command::{DeliveryObservation, DeliveryObservationOutcome, OperationError}, 10 workspace::{AttachmentProof, WorkspaceBinding}, 11 }; 12 use radroots_transport::sink::DeliveryRequestId; 13 14 impl BrowserWorkspace { 15 /// Retains an already obtained target fact under the original proof and 16 /// actual attempt. This grants no permission to dispatch or retry. 17 pub async fn record_delivery_observation( 18 &self, 19 binding: WorkspaceBinding, 20 proof: AttachmentProof, 21 supplied: DeliveryObservation, 22 ) -> Result<DeliveryObservationOutcome, OperationError> { 23 let capture_identity = crate::workspace::recovery::CaptureIdentity::observation(&supplied); 24 let owned_identity = capture_identity.clone(); 25 let fallback = supplied.clone(); 26 let work = self.state.admit_capture()?; 27 let state = self.state.clone(); 28 let result = owned(work, async move { 29 let input = binding.input().clone(); 30 let (grant, protected) = state.capture_retained(&input, &proof).await?; 31 let actual_work = supplied.work(); 32 let evidence = actual_work.evidence(); 33 let operation = evidence.operation_id(); 34 let view = state.read_view(operation).await?; 35 let t0 = state.operation_records(&view, operation).await?; 36 let facts = state 37 .delivery_facts( 38 &view, 39 operation, 40 Some(evidence.command_digest()), 41 &t0, 42 binding.observed_at(), 43 Some(Selection { 44 recipient: evidence.target(), 45 request: supplied.request_id(), 46 event: None, 47 retain_seal: false, 48 }), 49 ) 50 .await?; 51 let snapshot = facts.snapshot.ok_or(OperationError::InvalidEvidence)?; 52 radroots_storage::command::protected::same_binding( 53 snapshot.prepared().request().binding(), 54 &binding, 55 )?; 56 let attempt = facts.selected.ok_or(OperationError::InvalidEvidence)?; 57 if attempt.work() != actual_work { 58 return Err(OperationError::InvalidEvidence); 59 } 60 let checked = DeliveryObservation::from_store_report( 61 &attempt, 62 supplied.target_receipt(), 63 supplied.observed_at_unix_ms(), 64 )?; 65 if checked != supplied { 66 return Err(OperationError::InvalidEvidence); 67 } 68 let existing = snapshot.delivery_observations().iter().find(|value| { 69 value.work() == actual_work 70 && value.request_id() == supplied.request_id() 71 && value.target_receipt().target().fingerprint() 72 == supplied.target_receipt().target().fingerprint() 73 && value.kind() == supplied.kind() 74 }); 75 let retained = existing.cloned().unwrap_or(supplied); 76 let mut extra = if existing.is_some() { 77 Vec::new() 78 } else { 79 vec![ 80 observation::protect( 81 &state, 82 facts 83 .selected_slot 84 .ok_or(OperationError::RecoveryRequired)?, 85 &attempt, 86 &retained, 87 ) 88 .await?, 89 ] 90 }; 91 extra.extend(state.coordinate_guard(snapshot.prepared()).await?); 92 let batch = journal::mutations(protected, operation, t0, None, extra)?; 93 let active = state.active()?; 94 match state 95 .checked_batch(batch, view, move || { 96 if !active.get() { 97 return Err(WorkspaceError::Closed.into()); 98 } 99 grant.authenticate_retained_capture(&input, &proof)?; 100 Ok(()) 101 }) 102 .await 103 { 104 Ok(()) => { 105 state.capture_confirmed(&owned_identity); 106 Ok(DeliveryObservationOutcome::Committed(retained)) 107 } 108 Err(OperationError::Workspace(WorkspaceError::CommitUnknown)) => { 109 state.mark_capture_unknown(owned_identity); 110 Ok(DeliveryObservationOutcome::Unknown(retained)) 111 } 112 Err(error) => Err(error), 113 } 114 }) 115 .await; 116 match result { 117 Err(OperationError::Workspace(WorkspaceError::CommitUnknown)) => { 118 self.state.mark_capture_unknown(capture_identity); 119 Ok(DeliveryObservationOutcome::Unknown(fallback)) 120 } 121 other => other, 122 } 123 } 124 125 /// Queries original target facts under current access without dispatching. 126 pub async fn delivery_observations( 127 &self, 128 binding: WorkspaceBinding, 129 operation: OperationId, 130 digest: CommandDigest, 131 target: radroots_storage::command::SigningTarget, 132 request: DeliveryRequestId, 133 proof: AttachmentProof, 134 ) -> Result<Vec<DeliveryObservation>, OperationError> { 135 if !codec::valid_request(request.as_str()) { 136 return Err(OperationError::InvalidCommand); 137 } 138 let work = self.state.admit()?; 139 let state = self.state.clone(); 140 owned(work, async move { 141 let access = state.operation_access(&binding, proof).await?; 142 let recipient = target; 143 let view = state.read_view(operation).await?; 144 let t0 = state.operation_records(&view, operation).await?; 145 let facts = state 146 .delivery_facts( 147 &view, 148 operation, 149 Some(digest), 150 &t0, 151 access.binding.observed_at(), 152 Some(Selection { 153 recipient, 154 request: &request, 155 event: None, 156 retain_seal: false, 157 }), 158 ) 159 .await?; 160 let result = match facts.snapshot { 161 Some(snapshot) => { 162 radroots_storage::command::protected::same_binding( 163 snapshot.prepared().request().binding(), 164 &binding, 165 )?; 166 snapshot 167 .delivery_observations() 168 .iter() 169 .filter(|value| { 170 value.work().target() == recipient && value.request_id() == &request 171 }) 172 .cloned() 173 .collect() 174 } 175 None => Vec::new(), 176 }; 177 state 178 .check_operation(access, operation, OperationChange::observe(t0), view) 179 .await?; 180 Ok(result) 181 }) 182 .await 183 } 184 }