ic-query 0.93.1

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
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
116

use super::{
    SubnetCatalogFilters, SubnetCatalogListReport, SubnetCatalogListRequest,
    SubnetCatalogSubnetRow, load_catalog_for_report,
};
use crate::QueryProgress;
use crate::{
    nns::LiveNnsSource,
    subnet_catalog::{
        RoutingRange, SUBNET_CATALOG_LIST_REPORT_SCHEMA_VERSION, SubnetCatalogHostError,
        SubnetCatalogSource, SubnetInfo,
    },
};
use std::collections::BTreeMap;

/// Load the catalog under the request's cache policy and project its filtered Subnet rows.
pub async fn build_subnet_catalog_list_report(
    request: &SubnetCatalogListRequest,
) -> Result<SubnetCatalogListReport, SubnetCatalogHostError> {
    build_subnet_catalog_list_report_with_source_and_progress(
        request,
        &LiveNnsSource::default(),
        &mut |_| {},
    )
    .await
}

/// Build the report with a caller-owned source and progress sink.
pub async fn build_subnet_catalog_list_report_with_source_and_progress(
    request: &SubnetCatalogListRequest,
    source: &dyn SubnetCatalogSource,
    progress: &mut (dyn QueryProgress + Send),
) -> Result<SubnetCatalogListReport, SubnetCatalogHostError> {
    let (cached, stale) = load_catalog_for_report(
        &request.cache,
        &request.read_policy,
        request.now_unix_secs,
        request.stale_after_seconds,
        source,
        progress,
    )
    .await?;
    let subnets = cached
        .catalog
        .subnets()
        .iter()
        .filter(|subnet| subnet_matches_filters(subnet, request.filters))
        .collect::<Vec<_>>();
    let mut ranges_by_subnet = subnets
        .iter()
        .map(|subnet| (subnet.subnet_principal.as_str(), (0_usize, Vec::new())))
        .collect::<BTreeMap<_, _>>();
    for range in &cached.catalog.raw().routing_ranges {
        if let Some((count, shown)) = ranges_by_subnet.get_mut(range.subnet_principal.as_str()) {
            if request.show_ranges
                && *count >= request.range_offset
                && shown.len() < request.range_limit
            {
                shown.push(range.clone());
            }
            *count += 1;
        }
    }
    let subnets = subnets
        .into_iter()
        .map(|subnet| {
            let (count, ranges) = ranges_by_subnet
                .remove(subnet.subnet_principal.as_str())
                .unwrap_or_default();
            subnet_row(subnet, request, count, ranges)
        })
        .collect();

    Ok(SubnetCatalogListReport {
        metadata: super::SubnetCatalogReportMetadata::from_catalog(&cached.catalog),
        cache_disposition: cached.disposition,
        catalog_schema_version: cached.catalog.raw().catalog_schema_version,
        catalog_path: cached.path.display().to_string(),
        catalog_stale: stale.catalog_stale,
        stale_reason: stale.stale_reason,

        schema_version: SUBNET_CATALOG_LIST_REPORT_SCHEMA_VERSION,
        network: cached.catalog.provenance().network.clone(),
        subnets,
    })
}

fn subnet_matches_filters(subnet: &SubnetInfo, filters: SubnetCatalogFilters) -> bool {
    filters
        .kind
        .is_none_or(|kind| subnet.classification.subnet_kind == kind)
        && filters.specialization.is_none_or(|specialization| {
            subnet.classification.subnet_specialization == specialization
        })
        && filters
            .geographic_scope
            .is_none_or(|scope| subnet.classification.geographic_scope == scope)
}

fn subnet_row(
    subnet: &SubnetInfo,
    request: &SubnetCatalogListRequest,
    range_count: usize,
    shown_ranges: Vec<RoutingRange>,
) -> SubnetCatalogSubnetRow {
    SubnetCatalogSubnetRow {
        classification: subnet.classification.clone(),
        subnet_principal: subnet.subnet_principal.clone(),
        node_count: subnet.node_count,
        charges_apply_by_default: subnet.charges_apply_by_default,
        range_count,
        ranges_shown: shown_ranges.len(),
        range_offset: request.range_offset,
        range_limit: request.range_limit,
        ranges: shown_ranges,
    }
}