observation_operations.rs (8541B)
1 use super::super::{ 2 AttachmentProof, WorkspaceBinding, 3 admission::{Journal, recheck}, 4 installation::Records, 5 snapshot::RetainedGraph, 6 worker, 7 }; 8 use super::{ 9 graph::Graph, 10 observation::{self, Observations}, 11 }; 12 use radroots_domain::{CommandDigest, OperationId}; 13 use radroots_storage::command::{ 14 DeliveryObservation, DeliveryObservationOutcome, OperationError, SigningTarget, 15 }; 16 use radroots_transport::sink::DeliveryRequestId; 17 use sqlx::Connection; 18 19 impl Journal<'_> { 20 pub(in crate::workspace) async fn capture_delivery_observation( 21 &mut self, 22 binding: WorkspaceBinding, 23 proof: AttachmentProof, 24 supplied: DeliveryObservation, 25 ) -> Result<DeliveryObservationOutcome, OperationError> { 26 let (record, grant) = self.capture_access(binding.input(), &proof).await?; 27 let work = supplied.work(); 28 let e = work.evidence(); 29 let original = RetainedGraph::read( 30 self.connection, 31 self.selected, 32 &binding, 33 e.operation_id(), 34 Some(e.command_digest()), 35 self.crypto, 36 ) 37 .await?; 38 let installed = Records::read( 39 self.connection, 40 self.selected, 41 e.operation_id(), 42 &original, 43 self.crypto, 44 ) 45 .await?; 46 let public = super::super::listing_installation::Records::read( 47 self.connection, 48 self.selected, 49 e.operation_id(), 50 &original, 51 self.crypto, 52 ) 53 .await?; 54 let deliveries = Graph::read( 55 self.connection, 56 self.selected, 57 e.operation_id(), 58 &original, 59 &installed, 60 &public, 61 self.crypto, 62 ) 63 .await?; 64 let observations = Observations::read( 65 self.connection, 66 &deliveries, 67 self.selected, 68 e.operation_id(), 69 self.crypto, 70 ) 71 .await?; 72 let actual = deliveries 73 .attempts 74 .iter() 75 .find(|value| { 76 value.work() == work && value.intent().request_id() == supplied.request_id() 77 }) 78 .ok_or(OperationError::InvalidEvidence)?; 79 let checked = DeliveryObservation::from_store_report( 80 actual, 81 supplied.target_receipt(), 82 supplied.observed_at_unix_ms(), 83 )?; 84 if checked != supplied { 85 return Err(OperationError::InvalidEvidence); 86 } 87 let existing = observations.reports.iter().find(|value| { 88 value.request_id() == supplied.request_id() 89 && value.work() == work 90 && value.target_receipt().target().fingerprint() 91 == supplied.target_receipt().target().fingerprint() 92 && value.kind() == supplied.kind() 93 }); 94 // The first original outcome of each class, including absent time, is 95 // immutable. Further classes append; they do not replace earlier facts. 96 let retained = existing.cloned().unwrap_or(supplied); 97 let fresh = existing.is_none(); 98 let protected = if fresh { 99 Some(observation::protect(retained.clone(), self.crypto).await?) 100 } else { 101 None 102 }; 103 let mut transaction = self 104 .connection 105 .begin_with("BEGIN IMMEDIATE") 106 .await 107 .map_err(|_| OperationError::StorageFailure)?; 108 let changed = async { 109 self.namespace.validate()?; 110 if worker::read(&mut transaction, self.selected).await? != grant { 111 return Err(OperationError::RecoveryRequired); 112 } 113 record.authenticate_retained_capture(binding.input(), &proof)?; 114 original 115 .unchanged(&mut transaction, self.selected, e.operation_id()) 116 .await?; 117 installed 118 .unchanged(&mut transaction, self.selected, e.operation_id()) 119 .await?; 120 public 121 .unchanged(&mut transaction, self.selected, e.operation_id()) 122 .await?; 123 deliveries 124 .unchanged(&mut transaction, self.selected, e.operation_id()) 125 .await?; 126 observations 127 .unchanged(&mut transaction, self.selected, e.operation_id()) 128 .await?; 129 if let Some(value) = &protected { 130 value.insert(&mut transaction).await?; 131 } 132 Ok::<_, OperationError>(()) 133 } 134 .await; 135 if let Err(error) = changed { 136 if transaction.rollback().await.is_err() { 137 *self.uncertain = true; 138 return Ok(DeliveryObservationOutcome::Unknown(retained)); 139 } 140 return Err(error); 141 } 142 let finished = if fresh { 143 transaction.commit().await 144 } else { 145 transaction.rollback().await 146 }; 147 if finished.is_err() { 148 *self.uncertain = true; 149 return Ok(DeliveryObservationOutcome::Unknown(retained)); 150 } 151 Ok(DeliveryObservationOutcome::Committed(retained)) 152 } 153 154 pub(in crate::workspace) async fn query_delivery_observations( 155 &mut self, 156 binding: WorkspaceBinding, 157 operation: OperationId, 158 digest: CommandDigest, 159 target: SigningTarget, 160 request: DeliveryRequestId, 161 proof: AttachmentProof, 162 ) -> Result<Vec<DeliveryObservation>, OperationError> { 163 if request.as_str().len() != 64 164 || !request 165 .as_str() 166 .bytes() 167 .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) 168 { 169 return Err(OperationError::InvalidCommand); 170 } 171 let (record, grant, _) = self.access(&binding, &proof).await?; 172 let original = RetainedGraph::read( 173 self.connection, 174 self.selected, 175 &binding, 176 operation, 177 Some(digest), 178 self.crypto, 179 ) 180 .await?; 181 let installed = Records::read( 182 self.connection, 183 self.selected, 184 operation, 185 &original, 186 self.crypto, 187 ) 188 .await?; 189 let public = super::super::listing_installation::Records::read( 190 self.connection, 191 self.selected, 192 operation, 193 &original, 194 self.crypto, 195 ) 196 .await?; 197 let deliveries = Graph::read( 198 self.connection, 199 self.selected, 200 operation, 201 &original, 202 &installed, 203 &public, 204 self.crypto, 205 ) 206 .await?; 207 let observations = Observations::read( 208 self.connection, 209 &deliveries, 210 self.selected, 211 operation, 212 self.crypto, 213 ) 214 .await?; 215 let mut transaction = self 216 .connection 217 .begin_with("BEGIN IMMEDIATE") 218 .await 219 .map_err(|_| OperationError::StorageFailure)?; 220 let checked = async { 221 recheck( 222 &mut transaction, 223 self.namespace, 224 self.selected, 225 &grant, 226 &record, 227 &binding, 228 &proof, 229 self.clock, 230 ) 231 .await?; 232 original 233 .unchanged(&mut transaction, self.selected, operation) 234 .await?; 235 installed 236 .unchanged(&mut transaction, self.selected, operation) 237 .await?; 238 public 239 .unchanged(&mut transaction, self.selected, operation) 240 .await?; 241 deliveries 242 .unchanged(&mut transaction, self.selected, operation) 243 .await?; 244 observations 245 .unchanged(&mut transaction, self.selected, operation) 246 .await?; 247 Ok::<_, OperationError>(()) 248 } 249 .await; 250 if transaction.rollback().await.is_err() { 251 *self.uncertain = true; 252 return Err(OperationError::RecoveryRequired); 253 } 254 checked?; 255 Ok(observations 256 .reports 257 .into_iter() 258 .filter(|value| value.request_id() == &request && value.work().target() == target) 259 .collect()) 260 } 261 }