lib

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

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 }