ic-query 0.25.5

Internet Computer query library for 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

//! Module: nns::proposals::report::cache::attempt
//!
//! Responsibility: read and write NNS proposal refresh-attempt metadata.
//! Does not own: live proposal paging, cache publication, or text rendering.
//! Boundary: persists refresh lifecycle status for cache status reports.

use super::NNS_PROPOSAL_CACHE_COMPONENT;
use crate::{
    nns::{
        NnsGovernanceRefreshAttemptStatus, NnsGovernanceRefreshRequest,
        governance::{
            NnsGovernanceAttemptReadError, read_governance_refresh_attempt_status,
            write_failed_governance_refresh_attempt, write_governance_refresh_attempt,
        },
        proposals::report::NnsProposalHostError,
    },
    snapshot_cache::SnapshotRefreshProgress,
    subnet_catalog::MAINNET_NETWORK,
};
use std::path::Path;

pub(super) fn read_attempt_status(path: &Path) -> Option<NnsGovernanceRefreshAttemptStatus> {
    read_governance_refresh_attempt_status(path, MAINNET_NETWORK, NNS_PROPOSAL_CACHE_COMPONENT)
        .ok()
        .flatten()
}

pub(super) fn read_attempt_status_strict(
    path: &Path,
    expected_network: &str,
) -> Result<Option<NnsGovernanceRefreshAttemptStatus>, NnsProposalHostError> {
    read_governance_refresh_attempt_status(path, expected_network, NNS_PROPOSAL_CACHE_COMPONENT)
        .map_err(map_attempt_read_error)
}

pub(super) fn write_starting_attempt(
    path: &Path,
    request: &NnsGovernanceRefreshRequest,
) -> Result<(), NnsProposalHostError> {
    write_attempt_status(
        path,
        request,
        "running",
        SnapshotRefreshProgress::default(),
        None,
    )
}

pub(super) fn write_running_attempt(
    path: &Path,
    request: &NnsGovernanceRefreshRequest,
    progress: SnapshotRefreshProgress,
) -> Result<(), NnsProposalHostError> {
    write_attempt_status(path, request, "running", progress, None)
}

pub(super) fn write_complete_attempt(
    path: &Path,
    request: &NnsGovernanceRefreshRequest,
    progress: SnapshotRefreshProgress,
) -> Result<(), NnsProposalHostError> {
    write_attempt_status(path, request, "complete", progress, None)
}

pub(super) fn write_failed_attempt(
    path: &Path,
    request: &NnsGovernanceRefreshRequest,
    err: &NnsProposalHostError,
) {
    let _ = write_failed_governance_refresh_attempt(
        path,
        request,
        NNS_PROPOSAL_CACHE_COMPONENT,
        err.to_string(),
    );
}

fn map_attempt_read_error(error: NnsGovernanceAttemptReadError) -> NnsProposalHostError {
    match error {
        NnsGovernanceAttemptReadError::Cache(error) => NnsProposalHostError::Cache(error),
        NnsGovernanceAttemptReadError::Invalid { path, reason } => {
            NnsProposalHostError::InvalidRefreshAttempt { path, reason }
        }
    }
}

fn write_attempt_status(
    path: &Path,
    request: &NnsGovernanceRefreshRequest,
    status: &'static str,
    progress: SnapshotRefreshProgress,
    last_error: Option<String>,
) -> Result<(), NnsProposalHostError> {
    write_governance_refresh_attempt(
        path,
        request,
        NNS_PROPOSAL_CACHE_COMPONENT,
        status,
        progress,
        last_error,
    )
    .map_err(NnsProposalHostError::Cache)
}