ic-query-cli 0.44.2

Command-line wrapper for read-only Internet Computer metadata queries
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

//! Explicit live agreement with disk history reuse across fresh sources and processes.
use ic_query::subnet_catalog::{
    CatalogAssurance, CatalogReadPolicy, CatalogSourceSelection, LiveSubnetCatalogSource,
    RegistryHistoryCacheDisposition, SubnetCatalogCacheRequest, SubnetCatalogLoadRequest,
    SubnetCatalogProgressPhase, load_subnet_catalog_detailed_with_source,
};
use std::{
    path::Path,
    time::{Instant, SystemTime, UNIX_EPOCH},
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let root = std::env::args()
        .nth(1)
        .ok_or("supply a cache directory; every run performs live agreement")?;
    let now = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs();
    let request = SubnetCatalogLoadRequest::refresh_missing_or_invalid(
        SubnetCatalogCacheRequest::new(&root, "ic"),
        CatalogSourceSelection::multi_endpoint_agreement(vec![
            "https://ic0.app".into(),
            "https://icp-api.io".into(),
        ]),
        now,
    )
    .with_minimum_assurance(CatalogAssurance::MultiEndpointAgreement)
    .with_policy(CatalogReadPolicy::ForceRefresh {
        source: CatalogSourceSelection::multi_endpoint_agreement(vec![
            "https://ic0.app".into(),
            "https://icp-api.io".into(),
        ]),
    });
    let source = history_source(Path::new(&root));
    let start = Instant::now();
    let cold = load_subnet_catalog_detailed_with_source(&request, &source)?;
    println!(
        "acquisition_ms={} version={} calls={} agreement_digest={}",
        start.elapsed().as_millis(),
        cold.snapshot_authority().registry_version,
        cold.catalog.provenance().registry_query_call_count,
        cold.catalog
            .provenance()
            .agreement_digest
            .as_deref()
            .unwrap_or("none")
    );
    let start = Instant::now();
    let cache_only = request.clone().with_policy(CatalogReadPolicy::CacheOnly);
    let warm = load_subnet_catalog_detailed_with_source(&cache_only, &source)?;
    println!(
        "reuse_us={} authority_equal={}",
        start.elapsed().as_micros(),
        cold.snapshot_authority() == warm.snapshot_authority()
    );
    drop(source);
    let source = history_source(Path::new(&root));
    let start = Instant::now();
    let refreshed = load_subnet_catalog_detailed_with_source(&request, &source)?;
    println!(
        "fresh_source_refresh_ms={} version={} calls={} agreement_digest={}",
        start.elapsed().as_millis(),
        refreshed.snapshot_authority().registry_version,
        refreshed.catalog.provenance().registry_query_call_count,
        refreshed
            .catalog
            .provenance()
            .agreement_digest
            .as_deref()
            .unwrap_or("none")
    );
    Ok(())
}

fn history_source(root: &Path) -> LiveSubnetCatalogSource {
    LiveSubnetCatalogSource::with_progress(|event| {
        if let SubnetCatalogProgressPhase::HistoryCache { disposition, through_version, reason, .. } = event.phase
            && matches!(disposition, RegistryHistoryCacheDisposition::Reused | RegistryHistoryCacheDisposition::Rejected | RegistryHistoryCacheDisposition::Missing)
        {
            eprintln!("endpoint={} history_cache={disposition:?} through_version={through_version} reason={reason:?}", event.endpoint);
        }
    }).with_history_cache(root)
}