ic-query 0.2.18

Internet Computer query CLI for NNS, SNS, and related 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

use super::{
    error::NnsLeafHostCacheError,
    model::{NnsLeafCacheRequest, NnsLeafRefreshRequest},
    paths::NnsLeafCachePaths,
};
use crate::cache_file::{
    CachedJsonReport, JsonCacheReport, LoadJsonCacheErrorMapper, LoadJsonCacheRequest,
    RefreshCacheWriteRequest, RefreshCacheWriteResult, load_json_cache, write_json_refresh_cache,
};
use serde::{Serialize, de::DeserializeOwned};
use std::{io, path::PathBuf};

pub(in crate::nns) fn load_nns_leaf_json_cache<Cache, Report>(
    cache: &Cache,
    component_dir: &'static str,
    cache_file: &str,
    expected_schema_version: u32,
) -> Result<CachedJsonReport<Report>, NnsLeafHostCacheError>
where
    Cache: NnsLeafCacheRequest,
    Report: DeserializeOwned + JsonCacheReport,
{
    let paths = NnsLeafCachePaths::for_component(
        cache.icp_root(),
        component_dir,
        cache.network(),
        cache_file,
    );
    load_json_cache(
        LoadJsonCacheRequest {
            path: paths.cache_path,
            network: cache.network(),
            expected_schema_version,
        },
        NnsLeafLoadJsonCacheErrors {
            component: component_dir,
        },
    )
}

pub(in crate::nns) fn write_nns_leaf_json_refresh_cache<Request, Report>(
    request: &Request,
    component_dir: &'static str,
    cache_file: &str,
    report: &Report,
) -> Result<RefreshCacheWriteResult, NnsLeafHostCacheError>
where
    Request: NnsLeafRefreshRequest,
    Report: Serialize,
{
    let cache = request.cache();
    let paths = NnsLeafCachePaths::for_component(
        cache.icp_root(),
        component_dir,
        cache.network(),
        cache_file,
    );
    write_json_refresh_cache(
        RefreshCacheWriteRequest {
            cache_path: &paths.cache_path,
            lock_path: &paths.lock_path,
            network: cache.network(),
            now_unix_secs: request.now_unix_secs(),
            lock_stale_after_seconds: request.lock_stale_after_seconds(),
            dry_run: request.dry_run(),
            output_path: request.output_path(),
            report,
        },
        |err| NnsLeafHostCacheError::from_cache_file_error(component_dir, err),
        |path, source| NnsLeafHostCacheError::serialize_cache(component_dir, path, source),
    )
}

struct NnsLeafLoadJsonCacheErrors {
    component: &'static str,
}

impl LoadJsonCacheErrorMapper for NnsLeafLoadJsonCacheErrors {
    type Error = NnsLeafHostCacheError;

    fn missing_cache(&self, path: PathBuf) -> Self::Error {
        NnsLeafHostCacheError::missing_cache(self.component, path)
    }

    fn read_cache(&self, path: PathBuf, source: io::Error) -> Self::Error {
        NnsLeafHostCacheError::read_cache(self.component, path, source)
    }

    fn parse_cache(&self, path: PathBuf, source: serde_json::Error) -> Self::Error {
        NnsLeafHostCacheError::parse_cache(self.component, path, source)
    }

    fn unsupported_schema(&self, version: u32, expected: u32) -> Self::Error {
        NnsLeafHostCacheError::unsupported_cache_schema_version(self.component, version, expected)
    }

    fn network_mismatch(&self, requested: String, actual: String) -> Self::Error {
        NnsLeafHostCacheError::network_mismatch(self.component, requested, actual)
    }
}