prikk-store 0.24.0

Prikk storage crate scaffold.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use prikk_object::NodeId;

use super::types::{
    MergeEvidenceItem, MergeEvidenceOutcome, MergeEvidenceProofPhase, MergeEvidenceReasonCode,
    MergeEvidenceSide,
};
use crate::patch_algebra::evidence_types::{EvidenceError, EvidenceFact, EvidenceScope};

pub(super) fn evidence_error_report(
    error: &EvidenceError,
) -> (MergeEvidenceOutcome, Vec<MergeEvidenceItem>) {
    let scope = evidence_error_scope(error);
    let outcome = match scope {
        EvidenceScope::SealedBaselineRequired | EvidenceScope::SealedCandidateRequired => {
            MergeEvidenceOutcome::EvidenceFailure
        }
        EvidenceScope::UnsealedCandidateOptional => MergeEvidenceOutcome::InvalidCandidate,
    };
    (
        outcome,
        vec![MergeEvidenceItem {
            side: MergeEvidenceSide::Report,
            operation_index: None,
            peer_operation_index: None,
            op_seq: None,
            peer_op_seq: None,
            operation_kind: None,
            node_id: evidence_error_node_id(error),
            path: None,
            outcome,
            evidence_scope: Some(scope.into()),
            proof_phase: MergeEvidenceProofPhase::Classification,
            reason_code: evidence_error_reason_code(error, outcome),
        }],
    )
}

fn evidence_error_scope(error: &EvidenceError) -> EvidenceScope {
    match error {
        EvidenceError::Missing { scope, .. }
        | EvidenceError::WrongObjectType { scope, .. }
        | EvidenceError::WrongBlobKind { scope, .. }
        | EvidenceError::Malformed { scope, .. }
        | EvidenceError::Unreadable { scope, .. } => *scope,
    }
}

fn evidence_error_node_id(error: &EvidenceError) -> Option<NodeId> {
    match error {
        EvidenceError::Missing { node_id, .. } => *node_id,
        EvidenceError::WrongObjectType { .. }
        | EvidenceError::WrongBlobKind { .. }
        | EvidenceError::Malformed { .. }
        | EvidenceError::Unreadable { .. } => None,
    }
}

fn evidence_error_reason_code(
    error: &EvidenceError,
    outcome: MergeEvidenceOutcome,
) -> MergeEvidenceReasonCode {
    if outcome == MergeEvidenceOutcome::InvalidCandidate {
        return match error {
            EvidenceError::Missing { fact, .. } if *fact != EvidenceFact::Operation => {
                MergeEvidenceReasonCode::InsufficientUnsealedCandidateEvidence
            }
            _ => MergeEvidenceReasonCode::InvalidUnsealedCandidate,
        };
    }
    match error {
        EvidenceError::Missing { .. } => MergeEvidenceReasonCode::MissingRequiredEvidence,
        EvidenceError::WrongObjectType { .. } | EvidenceError::WrongBlobKind { .. } => {
            MergeEvidenceReasonCode::WrongTypeRequiredEvidence
        }
        EvidenceError::Malformed { .. } => MergeEvidenceReasonCode::MalformedRequiredEvidence,
        EvidenceError::Unreadable { .. } => MergeEvidenceReasonCode::UnreadableRequiredEvidence,
    }
}