operations.rs (15725B)
1 use super::super::{ 2 AttachmentProof, WorkspaceBinding, 3 admission::{Journal, recheck}, 4 installation::Records, 5 snapshot::RetainedGraph, 6 }; 7 use super::{codec, graph::Graph, observation::Observations}; 8 use radroots_domain::{CommandDigest, OperationId, TransactionId}; 9 use radroots_storage::command::{ 10 CommitAttempt, DeliveryAttempt, DeliveryAttemptOutcome, DeliveryAttemptRequest, 11 EnvelopeCandidate, OperationError, PublicationArtifact, PublicationWork, SigningTarget, 12 }; 13 use radroots_transport::sink::DeliveryRequestId; 14 use sqlx::Connection; 15 use zeroize::Zeroizing; 16 17 fn contains_original( 18 candidate: &EnvelopeCandidate, 19 work: PublicationWork, 20 original: &RetainedGraph, 21 ) -> Result<(), OperationError> { 22 let bound = original 23 .bound_plan() 24 .ok_or(OperationError::RecoveryRequired)?; 25 let source = original 26 .obtained(work.recipient()) 27 .ok_or(OperationError::RecoveryRequired)?; 28 let actor = bound 29 .prepared() 30 .request() 31 .command() 32 .context() 33 .actor() 34 .participant(); 35 if candidate.work() != work 36 || candidate.author() == actor 37 || candidate.author() == bound.prepared().request().chat_command()?.peer() 38 || candidate.author() == work.recipient() 39 || source.digest() != work.evidence().digest() 40 { 41 return Err(OperationError::InvalidEvidence); 42 } 43 candidate.with_wrapping_key(|key| { 44 super::containment::verify( 45 candidate.raw_json(), 46 candidate.author(), 47 key, 48 work.recipient(), 49 source.raw_json(), 50 source.digest(), 51 ) 52 })?; 53 Ok(()) 54 } 55 fn work( 56 records: &Records, 57 public: &super::super::listing_installation::Records, 58 requested: PublicationArtifact, 59 ) -> Result<PublicationArtifact, OperationError> { 60 let actual = match requested { 61 PublicationArtifact::Private(v) => PublicationArtifact::Private( 62 records 63 .work 64 .iter() 65 .find(|r| r.report.recipient() == v.recipient()) 66 .ok_or(OperationError::InvalidEvidence)? 67 .report, 68 ), 69 PublicationArtifact::Public(_) => { 70 PublicationArtifact::Public(public.work().ok_or(OperationError::InvalidEvidence)?) 71 } 72 }; 73 if actual != requested { 74 return Err(OperationError::InvalidEvidence); 75 } 76 Ok(actual) 77 } 78 fn unknown(anchor: CommitAttempt, attempt: DeliveryRequestId) -> DeliveryAttemptOutcome { 79 DeliveryAttemptOutcome::Unknown { 80 operation: anchor, 81 attempt, 82 } 83 } 84 85 impl Journal<'_> { 86 pub(in crate::workspace) async fn prepare_delivery( 87 &mut self, 88 request: DeliveryAttemptRequest, 89 proof: AttachmentProof, 90 candidate: Option<EnvelopeCandidate>, 91 ) -> Result<DeliveryAttemptOutcome, OperationError> { 92 let supplied = request.work(); 93 let evidence = supplied.evidence(); 94 let (record, grant, current) = self.access(request.binding(), &proof).await?; 95 let original = RetainedGraph::read( 96 self.connection, 97 self.selected, 98 request.binding(), 99 evidence.operation_id(), 100 Some(evidence.command_digest()), 101 self.crypto, 102 ) 103 .await?; 104 let installed = Records::read( 105 self.connection, 106 self.selected, 107 evidence.operation_id(), 108 &original, 109 self.crypto, 110 ) 111 .await?; 112 let public = super::super::listing_installation::Records::read( 113 self.connection, 114 self.selected, 115 evidence.operation_id(), 116 &original, 117 self.crypto, 118 ) 119 .await?; 120 let actual = work(&installed, &public, supplied)?; 121 let mut deliveries = Graph::read( 122 self.connection, 123 self.selected, 124 evidence.operation_id(), 125 &original, 126 &installed, 127 &public, 128 self.crypto, 129 ) 130 .await?; 131 let existing = deliveries.attempts.iter().position(|value| { 132 value.work().target() == evidence.target() 133 && value.intent().request_id() == request.intent().request_id() 134 }); 135 let observations = Observations::read( 136 self.connection, 137 &deliveries, 138 self.selected, 139 evidence.operation_id(), 140 self.crypto, 141 ) 142 .await?; 143 if let Some(index) = existing { 144 let value = &deliveries.attempts[index]; 145 if value.work() != actual 146 || value.intent().digest() != request.intent().digest() 147 || candidate.as_ref().is_some_and(|candidate| { 148 PublicationArtifact::Private(candidate.work()) != actual 149 || candidate.raw_json() != value.raw_json() 150 }) 151 { 152 return Err(OperationError::IdempotencyConflict); 153 } 154 } 155 let fresh = existing.is_none(); 156 if deliveries.attempts.iter().any(|value| { 157 value.work() == actual 158 && value.intent().publication_policy_digest() 159 != request.intent().publication_policy_digest() 160 }) { 161 return Err(OperationError::IdempotencyConflict); 162 } 163 let prepared = if fresh { 164 let bound = original 165 .bound_plan() 166 .ok_or(OperationError::RecoveryRequired)?; 167 super::require_target(self.connection, actual.target()).await?; 168 deliveries.authorize_routes(bound, actual.target())?; 169 let ordinals = deliveries.ordinals(actual.target(), request.intent())?; 170 if current.observed_at() < actual.queued_at() 171 || deliveries 172 .attempts 173 .iter() 174 .any(|value| value.retained_at() > current.observed_at()) 175 { 176 return Err(super::super::WorkspaceError::Unavailable.into()); 177 } 178 if current 179 .observed_at() 180 .get() 181 .checked_mul(1000) 182 .is_none_or(|now| now >= request.intent().deadline_unix_ms().get()) 183 { 184 return Err(OperationError::DeadlineExceeded); 185 } 186 let raw = match (actual, &candidate) { 187 (PublicationArtifact::Public(_), None) => { 188 let source = original 189 .obtained_artifact(SigningTarget::PublicEvent) 190 .ok_or(OperationError::InvalidEvidence)?; 191 if request.intent().event_id() != source.event_id() { 192 return Err(OperationError::InvalidEvidence); 193 } 194 Zeroizing::new(String::from(source.raw_json())) 195 } 196 (PublicationArtifact::Public(_), Some(_)) => { 197 return Err(OperationError::InvalidEvidence); 198 } 199 (PublicationArtifact::Private(private), Some(candidate)) => { 200 if candidate.event_id() != request.intent().event_id() { 201 return Err(OperationError::InvalidEvidence); 202 } 203 contains_original(candidate, private, &original)?; 204 Zeroizing::new(String::from(candidate.raw_json())) 205 } 206 (PublicationArtifact::Private(_), None) => { 207 let retained = deliveries 208 .attempts 209 .iter() 210 .find(|value| { 211 value.work() == actual 212 && value.intent().event_id() == request.intent().event_id() 213 }) 214 .ok_or(OperationError::InvalidEvidence)?; 215 Zeroizing::new(String::from(retained.raw_json())) 216 } 217 }; 218 // A second representation of one outer ID cannot replace the first. 219 if deliveries.attempts.iter().any(|value| { 220 value.work() == actual 221 && value.intent().event_id() == request.intent().event_id() 222 && value.raw_json() != raw.as_str() 223 }) { 224 return Err(OperationError::IdempotencyConflict); 225 } 226 let value = DeliveryAttempt::from_store_report( 227 actual, 228 request.intent().clone(), 229 &raw, 230 TransactionId::from_bytes(super::super::random()?), 231 current.observed_at(), 232 ordinals, 233 )?; 234 Some(codec::protect(value, self.crypto).await?) 235 } else { 236 None 237 }; 238 let retained = match (&prepared, existing) { 239 (Some(value), _) => &value.report, 240 (None, Some(index)) => &deliveries.attempts[index], 241 _ => return Err(OperationError::RecoveryRequired), 242 }; 243 let anchor = CommitAttempt::new( 244 evidence.workspace_id(), 245 evidence.operation_id(), 246 evidence.command_digest(), 247 Some(retained.transaction_id()), 248 ); 249 let identity = request.intent().request_id().clone(); 250 let mut transaction = self 251 .connection 252 .begin_with("BEGIN IMMEDIATE") 253 .await 254 .map_err(|_| OperationError::StorageFailure)?; 255 let changed = async { 256 let now = recheck( 257 &mut transaction, 258 self.namespace, 259 self.selected, 260 &grant, 261 &record, 262 request.binding(), 263 &proof, 264 self.clock, 265 ) 266 .await?; 267 original 268 .unchanged(&mut transaction, self.selected, evidence.operation_id()) 269 .await?; 270 installed 271 .unchanged(&mut transaction, self.selected, evidence.operation_id()) 272 .await?; 273 public 274 .unchanged(&mut transaction, self.selected, evidence.operation_id()) 275 .await?; 276 deliveries 277 .unchanged(&mut transaction, self.selected, evidence.operation_id()) 278 .await?; 279 observations 280 .unchanged(&mut transaction, self.selected, evidence.operation_id()) 281 .await?; 282 if fresh { 283 if now.observed_at() < current.observed_at() { 284 return Err(super::super::WorkspaceError::Unavailable.into()); 285 } 286 if now 287 .observed_at() 288 .get() 289 .checked_mul(1000) 290 .is_none_or(|now| now >= request.intent().deadline_unix_ms().get()) 291 { 292 return Err(OperationError::DeadlineExceeded); 293 } 294 codec::absent( 295 &mut transaction, 296 actual, 297 codec::request_key(identity.as_str()), 298 ) 299 .await?; 300 codec::insert( 301 &mut transaction, 302 prepared.as_ref().ok_or(OperationError::RecoveryRequired)?, 303 ) 304 .await?; 305 } 306 Ok::<_, OperationError>(()) 307 } 308 .await; 309 if let Err(error) = changed { 310 if transaction.rollback().await.is_err() { 311 *self.uncertain = true; 312 return Ok(unknown(anchor, identity)); 313 } 314 return Err(error); 315 } 316 let completed = if fresh { 317 transaction.commit().await 318 } else { 319 transaction.rollback().await 320 }; 321 if completed.is_err() { 322 *self.uncertain = true; 323 return Ok(unknown(anchor, identity)); 324 } 325 match prepared { 326 Some(value) => Ok(DeliveryAttemptOutcome::Claimed(Box::new(value.report))), 327 None => Ok(DeliveryAttemptOutcome::Retained(Box::new( 328 deliveries 329 .attempts 330 .remove(existing.ok_or(OperationError::RecoveryRequired)?), 331 ))), 332 } 333 } 334 335 pub(in crate::workspace) async fn query_delivery( 336 &mut self, 337 binding: WorkspaceBinding, 338 operation: OperationId, 339 digest: CommandDigest, 340 target: SigningTarget, 341 request: DeliveryRequestId, 342 proof: AttachmentProof, 343 ) -> Result<Option<DeliveryAttempt>, OperationError> { 344 if request.as_str().len() != 64 345 || !request 346 .as_str() 347 .bytes() 348 .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) 349 { 350 return Err(OperationError::InvalidCommand); 351 } 352 let (record, grant, _) = self.access(&binding, &proof).await?; 353 let original = RetainedGraph::read( 354 self.connection, 355 self.selected, 356 &binding, 357 operation, 358 Some(digest), 359 self.crypto, 360 ) 361 .await?; 362 let installed = Records::read( 363 self.connection, 364 self.selected, 365 operation, 366 &original, 367 self.crypto, 368 ) 369 .await?; 370 let public = super::super::listing_installation::Records::read( 371 self.connection, 372 self.selected, 373 operation, 374 &original, 375 self.crypto, 376 ) 377 .await?; 378 let mut deliveries = Graph::read( 379 self.connection, 380 self.selected, 381 operation, 382 &original, 383 &installed, 384 &public, 385 self.crypto, 386 ) 387 .await?; 388 let observations = Observations::read( 389 self.connection, 390 &deliveries, 391 self.selected, 392 operation, 393 self.crypto, 394 ) 395 .await?; 396 let mut transaction = self 397 .connection 398 .begin_with("BEGIN IMMEDIATE") 399 .await 400 .map_err(|_| OperationError::StorageFailure)?; 401 let checked = async { 402 recheck( 403 &mut transaction, 404 self.namespace, 405 self.selected, 406 &grant, 407 &record, 408 &binding, 409 &proof, 410 self.clock, 411 ) 412 .await?; 413 original 414 .unchanged(&mut transaction, self.selected, operation) 415 .await?; 416 installed 417 .unchanged(&mut transaction, self.selected, operation) 418 .await?; 419 public 420 .unchanged(&mut transaction, self.selected, operation) 421 .await?; 422 deliveries 423 .unchanged(&mut transaction, self.selected, operation) 424 .await?; 425 observations 426 .unchanged(&mut transaction, self.selected, operation) 427 .await?; 428 Ok::<_, OperationError>(()) 429 } 430 .await; 431 if transaction.rollback().await.is_err() { 432 *self.uncertain = true; 433 return Err(OperationError::RecoveryRequired); 434 } 435 checked?; 436 Ok(deliveries 437 .attempts 438 .iter() 439 .position(|value| { 440 value.work().target() == target && value.intent().request_id() == &request 441 }) 442 .map(|index| deliveries.attempts.remove(index))) 443 } 444 }