lib

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

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 }