lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }