sim-lib-bridge 0.1.1

Checked BRIDGE packet runtime for SIM model exchanges.
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use std::collections::{BTreeMap, BTreeSet};

use sim_codec_bridge::{
    BridgeBook, BridgePacket, BridgeWarrant, BridgeWarrantPolicy, content_id_string,
    frame_book_content_id, move_book_content_id, part_spec_content_id,
};
use sim_kernel::{ContentId, Cx, Result, Symbol};

use crate::materialize::fetch_obligation;
use crate::report::BridgeObligation;

/// Verifies a packet warrant against the local bridge book.
///
/// A warrant miss is a Fetch obligation, never a hard fail or silent accept.
pub fn verify_warrant(
    _cx: &mut Cx,
    book: &BridgeBook,
    packet: &BridgePacket,
) -> Result<Vec<BridgeObligation>> {
    if book.warrant_policy == BridgeWarrantPolicy::SharedTrust {
        return Ok(Vec::new());
    }
    let Some(warrant) = &packet.warrant else {
        return Ok(vec![fetch_obligation("warrant", "bridge/Warrant")]);
    };

    let mut obligations = Vec::new();
    check_book_id(
        &mut obligations,
        "warrant/moves",
        &warrant.moves,
        &move_book_content_id(&book.moves)?,
    );
    check_book_id(
        &mut obligations,
        "warrant/frames",
        &warrant.frames,
        &frame_book_content_id(&book.frames)?,
    );
    check_part_ids(&mut obligations, book, packet, warrant)?;
    Ok(obligations)
}

fn check_book_id(
    obligations: &mut Vec<BridgeObligation>,
    path: &str,
    declared: &ContentId,
    local: &ContentId,
) {
    if declared != local {
        obligations.push(fetch_content_id(path, declared));
    }
}

fn check_part_ids(
    obligations: &mut Vec<BridgeObligation>,
    book: &BridgeBook,
    packet: &BridgePacket,
    warrant: &BridgeWarrant,
) -> Result<()> {
    let declared = warrant
        .parts
        .iter()
        .map(|(kind, cid)| (kind.clone(), cid))
        .collect::<BTreeMap<Symbol, &ContentId>>();
    let mut seen = BTreeSet::new();
    for (kind, declared_cid) in &warrant.parts {
        let path = part_path(kind);
        if !seen.insert(kind.clone()) {
            obligations.push(fetch_content_id(path, declared_cid));
        }
    }

    let mut used = BTreeSet::new();
    for part in &packet.body {
        if !used.insert(part.kind.clone()) {
            continue;
        }
        let path = part_path(&part.kind);
        let Some(declared_cid) = declared.get(&part.kind).copied() else {
            obligations.push(fetch_missing_part(&path, &part.kind));
            continue;
        };
        let Some(spec) = book.parts.spec(&part.kind) else {
            obligations.push(fetch_content_id(path, declared_cid));
            continue;
        };
        let local = part_spec_content_id(spec)?;
        if declared_cid != &local {
            obligations.push(fetch_content_id(path, declared_cid));
        }
    }

    for (kind, declared_cid) in &warrant.parts {
        if !used.contains(kind) {
            obligations.push(fetch_content_id(part_path(kind), declared_cid));
        }
    }
    Ok(())
}

fn fetch_missing_part(path: &str, kind: &Symbol) -> BridgeObligation {
    fetch_obligation(
        path.to_owned(),
        format!("bridge/Fetch part spec {}", kind.as_qualified_str()),
    )
}

fn fetch_content_id(path: impl Into<String>, id: &ContentId) -> BridgeObligation {
    fetch_obligation(path, format!("bridge/Fetch {}", content_id_string(id)))
}

fn part_path(kind: &Symbol) -> String {
    format!("warrant/parts/{}", kind.as_qualified_str())
}