pleiades-backend 0.5.2

Backend traits, request/result contracts, capability metadata, policy summaries, and routing helpers for pleiades ephemeris backends.
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

use crate::claims::{BodyClaim, BodyClaimTier};
use crate::identity::BackendId;
use crate::metadata::BackendMetadata;
use pleiades_types::CelestialBody;

/// A derived, cross-backend view of body claims for release reporting.
#[derive(Clone, Debug, PartialEq)]
pub struct ReleasePosture {
    /// Flat (backend, claim) entries, ordered deterministically.
    pub entries: Vec<(BackendId, BodyClaim)>,
}

impl ReleasePosture {
    /// Aggregates claims across the given backend metadata (the caller chooses the set).
    pub fn from_backends(metas: &[&BackendMetadata]) -> Self {
        let mut entries: Vec<(BackendId, BodyClaim)> = Vec::new();
        for meta in metas {
            for claim in &meta.body_claims {
                entries.push((meta.id.clone(), claim.clone()));
            }
        }
        entries.sort_by(|a, b| {
            a.0.as_str()
                .cmp(b.0.as_str())
                .then_with(|| a.1.body.to_string().cmp(&b.1.body.to_string()))
        });
        Self { entries }
    }

    /// Returns the `(backend, body)` pairs claimed `ReleaseGrade`.
    pub fn release_grade(&self) -> Vec<(BackendId, CelestialBody)> {
        self.entries
            .iter()
            .filter(|(_, c)| c.tier == BodyClaimTier::ReleaseGrade)
            .map(|(id, c)| (id.clone(), c.body.clone()))
            .collect()
    }

    /// Returns the entries at a given tier.
    pub fn claims_for_tier(&self, tier: BodyClaimTier) -> Vec<(BackendId, BodyClaim)> {
        self.entries
            .iter()
            .filter(|(_, c)| c.tier == tier)
            .cloned()
            .collect()
    }

    /// Renders a deterministic one-line summary grouped by tier.
    pub fn summary_line(&self) -> String {
        let render = |tier: BodyClaimTier| -> String {
            self.entries
                .iter()
                .filter(|(_, c)| c.tier == tier)
                .map(|(id, c)| format!("{}@{}", c.body, id))
                .collect::<Vec<_>>()
                .join(", ")
        };
        format!(
            "ReleaseGrade: [{}]; Constrained: [{}]; Approximate: [{}]; Unsupported: [{}]",
            render(BodyClaimTier::ReleaseGrade),
            render(BodyClaimTier::Constrained),
            render(BodyClaimTier::Approximate),
            render(BodyClaimTier::Unsupported),
        )
    }
}

#[cfg(test)]
#[path = "release_posture_tests.rs"]
mod tests;