canic-core 0.35.7

Canic — a canister orchestration and management toolkit for the Internet Computer
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
117
118
119
120
121
122
123
124

use crate::{
    dto::{
        cycles::{CycleTopupEvent, CycleTopupEventStatus, CycleTrackerEntry},
        page::Page,
    },
    ops::prelude::*,
    storage::stable::cycles::{
        CycleTopupEventKey, CycleTopupEventRecord, CycleTopupEvents, CycleTracker,
    },
};

const TOPUP_ERROR_MAX_CHARS: usize = 256;

///
/// CycleTrackerOps
/// Stable storage wrapper for the cycle tracker.
///

pub struct CycleTrackerOps;

impl CycleTrackerOps {
    pub fn record(now: u64, cycles: Cycles) {
        CycleTracker::record(now, cycles);
    }

    #[must_use]
    pub fn purge_before(cutoff: u64) -> usize {
        CycleTracker::purge_before(cutoff)
    }

    #[must_use]
    pub fn entries() -> Vec<(u64, Cycles)> {
        CycleTracker::entries(0, usize::MAX)
    }

    #[must_use]
    pub fn page_to_response(page: Page<(u64, Cycles)>) -> Page<CycleTrackerEntry> {
        Page {
            entries: page
                .entries
                .into_iter()
                .map(|(timestamp_secs, cycles)| CycleTrackerEntry {
                    timestamp_secs,
                    cycles,
                })
                .collect(),
            total: page.total,
        }
    }
}

///
/// CycleTopupEventOps
/// Stable storage wrapper for cycle top-up event history.
///

pub struct CycleTopupEventOps;

impl CycleTopupEventOps {
    pub fn record_scheduled(now: u64, requested_cycles: Cycles) {
        CycleTopupEvents::record(
            now,
            requested_cycles,
            None,
            CycleTopupEventStatus::RequestScheduled,
            None,
        );
    }

    pub fn record_ok(now: u64, requested_cycles: Cycles, transferred_cycles: Cycles) {
        CycleTopupEvents::record(
            now,
            requested_cycles,
            Some(transferred_cycles),
            CycleTopupEventStatus::RequestOk,
            None,
        );
    }

    pub fn record_err(now: u64, requested_cycles: Cycles, error: String) {
        CycleTopupEvents::record(
            now,
            requested_cycles,
            None,
            CycleTopupEventStatus::RequestErr,
            Some(truncate_topup_error(error)),
        );
    }

    #[must_use]
    pub fn purge_before(cutoff: u64) -> usize {
        CycleTopupEvents::purge_before(cutoff)
    }

    #[must_use]
    pub fn entries() -> Vec<(CycleTopupEventKey, CycleTopupEventRecord)> {
        CycleTopupEvents::entries(0, usize::MAX)
    }

    #[must_use]
    pub fn page_to_response(
        page: Page<(CycleTopupEventKey, CycleTopupEventRecord)>,
    ) -> Page<CycleTopupEvent> {
        Page {
            entries: page
                .entries
                .into_iter()
                .map(|(key, record)| CycleTopupEvent {
                    timestamp_secs: key.timestamp_secs,
                    sequence: key.sequence,
                    requested_cycles: record.requested_cycles,
                    transferred_cycles: record.transferred_cycles,
                    status: record.status,
                    error: record.error,
                })
                .collect(),
            total: page.total,
        }
    }
}

fn truncate_topup_error(error: String) -> String {
    error.chars().take(TOPUP_ERROR_MAX_CHARS).collect()
}