canic-core 0.27.3

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

use crate::{
    cdk::candid::Principal,
    dto::placement::sharding::{ShardEntry, ShardingPlanStateResponse},
    storage::stable::sharding::{ShardEntryRecord, ShardKey},
    view::placement::sharding::{ShardPartitionKeyAssignment, ShardPlacement, ShardingPlanState},
};

///
/// ShardPlacementPolicyInputMapper
///

pub struct ShardPlacementPolicyInputMapper;

impl ShardPlacementPolicyInputMapper {
    #[must_use]
    pub fn record_to_policy_input(
        pid: Principal,
        entry: &ShardEntryRecord,
    ) -> (Principal, ShardPlacement) {
        (
            pid,
            ShardPlacement {
                pool: entry.pool.to_string(),
                slot: entry.slot,
                capacity: entry.capacity,
                count: entry.count,
            },
        )
    }
}

///
/// ShardPartitionKeyAssignmentPolicyInputMapper
///

pub struct ShardPartitionKeyAssignmentPolicyInputMapper;

impl ShardPartitionKeyAssignmentPolicyInputMapper {
    #[must_use]
    pub fn record_to_policy_input(key: &ShardKey, pid: Principal) -> ShardPartitionKeyAssignment {
        ShardPartitionKeyAssignment {
            partition_key: key.partition_key.to_string(),
            pid,
        }
    }
}

///
/// ShardEntryMapper
///

pub struct ShardEntryMapper;

impl ShardEntryMapper {
    #[must_use]
    pub fn record_to_view(entry: &ShardEntryRecord) -> ShardEntry {
        ShardEntry {
            slot: entry.slot,
            capacity: entry.capacity,
            count: entry.count,
            pool: entry.pool.to_string(),
            canister_role: entry.canister_role.clone(),
            created_at: entry.created_at,
        }
    }
}

///
/// ShardingPlanStateResponseMapper
///

pub struct ShardingPlanStateResponseMapper;

impl ShardingPlanStateResponseMapper {
    #[must_use]
    pub fn record_to_view(state: ShardingPlanState) -> ShardingPlanStateResponse {
        match state {
            ShardingPlanState::AlreadyAssigned { pid } => {
                ShardingPlanStateResponse::AlreadyAssigned { pid }
            }
            ShardingPlanState::UseExisting { pid } => {
                ShardingPlanStateResponse::UseExisting { pid }
            }
            ShardingPlanState::CreateAllowed => ShardingPlanStateResponse::CreateAllowed,
            ShardingPlanState::CreateBlocked { reason } => {
                ShardingPlanStateResponse::CreateBlocked {
                    reason: reason.to_string(),
                }
            }
        }
    }
}