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

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

use super::NNS_NEURON_CACHE_COMPONENT;
use crate::{
    nns::{
        NnsGovernanceRefreshAttemptStatus, NnsGovernanceRefreshRequest,
        governance::{
            NnsGovernanceAttemptReadError, read_governance_refresh_attempt_status,
            write_failed_governance_refresh_attempt, write_governance_refresh_attempt,
        },
        neuron::report::NnsNeuronHostError,
    },
    snapshot_cache::SnapshotRefreshProgress,
};
use std::path::Path;

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

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

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

pub(super) fn write_failed_attempt(
    path: &Path,
    request: &NnsGovernanceRefreshRequest,
    error: &NnsNeuronHostError,
) -> Result<(), NnsNeuronHostError> {
    write_failed_governance_refresh_attempt(
        path,
        request,
        NNS_NEURON_CACHE_COMPONENT,
        error.to_string(),
    )
    .map_err(NnsNeuronHostError::Cache)
}

pub(super) fn read_attempt_status(
    path: &Path,
    network: &str,
) -> Result<Option<NnsGovernanceRefreshAttemptStatus>, NnsNeuronHostError> {
    read_governance_refresh_attempt_status(path, network, NNS_NEURON_CACHE_COMPONENT)
        .map_err(map_attempt_read_error)
}

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

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