ic-query 0.67.0

Internet Computer query library for CloudEngine, NNS, SNS, ICRC, system canisters, and public network metadata
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

//! Module: snapshot_cache::json
//!
//! Responsibility: load shared complete-snapshot JSON files.
//! Does not own: snapshot path discovery, refresh attempts, or family-specific schemas.
//! Boundary: validates complete snapshot envelopes through cache-file JSON helpers.

use super::{SnapshotEnvelope, SnapshotIdentityMismatch, SnapshotKey};
use crate::{
    cache::CacheCollectionCompleteness,
    cache_file::{
        CachedJsonReport, HostCacheError, LoadJsonCacheRequest, ManagedReadBudget, load_json_cache,
    },
};
use serde::de::DeserializeOwned;
use std::path::PathBuf;

pub fn load_complete_snapshot_for_key<Metadata, Data, Error>(
    request: LoadJsonCacheRequest<'_>,
    budget: Option<&mut ManagedReadBudget>,
    key: &SnapshotKey,
    missing_error: impl FnOnce(PathBuf) -> Error,
    incomplete_error: impl FnOnce(&CacheCollectionCompleteness) -> Error,
    identity_error: impl FnOnce(SnapshotIdentityMismatch) -> Error,
) -> Result<SnapshotEnvelope<Metadata, Data>, Error>
where
    Metadata: DeserializeOwned,
    Data: DeserializeOwned,
    Error: From<HostCacheError>,
{
    let cached: CachedJsonReport<SnapshotEnvelope<Metadata, Data>> =
        load_json_cache(request, budget).map_err(|error| match error {
            HostCacheError::MissingCache { path, .. } => missing_error(path),
            error => error.into(),
        })?;
    let snapshot = cached.report;
    if !snapshot.completeness.is_api_exhausted() {
        return Err(incomplete_error(&snapshot.completeness));
    }
    if let Some(mismatch) = snapshot_identity_mismatch(&snapshot, key) {
        return Err(identity_error(mismatch));
    }
    Ok(snapshot)
}

fn snapshot_identity_mismatch<Metadata, Data>(
    snapshot: &SnapshotEnvelope<Metadata, Data>,
    key: &SnapshotKey,
) -> Option<SnapshotIdentityMismatch> {
    identity_field_mismatch("domain", key.domain(), &snapshot.domain)
        .or_else(|| identity_field_mismatch("entity", key.entity(), &snapshot.entity))
        .or_else(|| identity_field_mismatch("collection", key.collection(), &snapshot.collection))
        .or_else(|| {
            identity_field_mismatch("scope", SnapshotKey::scope_file_stem(), &snapshot.scope)
        })
}

fn identity_field_mismatch(
    field: &'static str,
    expected: &str,
    actual: &str,
) -> Option<SnapshotIdentityMismatch> {
    (actual != expected).then(|| SnapshotIdentityMismatch {
        field,
        expected: expected.to_string(),
        actual: actual.to_string(),
    })
}