canic-core 0.100.79

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

//! Module: ops::storage::directory::mapper
//!
//! Responsibility: convert Fleet/Subnet Directory data to boundary views and inputs.
//! Does not own: stable Directory mutation, workflow orchestration, or DTO definitions.
//! Boundary: storage ops conversion layer for topology Directory snapshots.

use crate::{
    dto::topology::{
        DirectoryEntryInput, DirectoryProvenance, FleetDirectoryInput, SubnetDirectoryInput,
    },
    model::topology::TopologyDirectoryEntry,
    storage::stable::directory::{
        DirectoryEntryRecord, fleet::FleetDirectoryData, subnet::SubnetDirectoryData,
    },
};

// -----------------------------------------------------------------------------
// Helpers
// -----------------------------------------------------------------------------

// Map stored Directory records into the shared input entry shape.
fn data_entries_to_input(entries: Vec<DirectoryEntryRecord>) -> Vec<DirectoryEntryInput> {
    entries
        .into_iter()
        .map(|entry| DirectoryEntryInput {
            role: entry.role,
            pid: entry.pid,
        })
        .collect()
}

// Map Directory input entries back into stored records.
fn input_entries_to_data(entries: Vec<DirectoryEntryInput>) -> Vec<DirectoryEntryRecord> {
    entries
        .into_iter()
        .map(|entry| DirectoryEntryRecord {
            role: entry.role,
            pid: entry.pid,
        })
        .collect()
}

///
/// FleetDirectoryDataMapper
///
/// Storage-ops mapper for Fleet Directory data and boundary input shapes.
///

pub struct FleetDirectoryDataMapper;

impl FleetDirectoryDataMapper {
    #[must_use]
    pub fn data_to_input(
        data: FleetDirectoryData,
        provenance: DirectoryProvenance,
    ) -> FleetDirectoryInput {
        FleetDirectoryInput {
            provenance,
            entries: data_entries_to_input(data.entries),
        }
    }

    #[must_use]
    pub fn input_to_data(input: FleetDirectoryInput) -> FleetDirectoryData {
        FleetDirectoryData {
            entries: input_entries_to_data(input.entries),
        }
    }
}

///
/// SubnetDirectoryDataMapper
///
/// Storage-ops mapper for Subnet Directory data and boundary input shapes.
///

pub struct SubnetDirectoryDataMapper;

impl SubnetDirectoryDataMapper {
    #[must_use]
    pub fn data_to_input(
        data: SubnetDirectoryData,
        provenance: DirectoryProvenance,
    ) -> SubnetDirectoryInput {
        SubnetDirectoryInput {
            provenance,
            entries: data_entries_to_input(data.entries),
        }
    }

    #[must_use]
    pub fn input_to_data(input: SubnetDirectoryInput) -> SubnetDirectoryData {
        SubnetDirectoryData {
            entries: input_entries_to_data(input.entries),
        }
    }
}

///
/// DirectoryEntryMapper
///
/// Storage-ops mapper for Directory records, policy inputs, and response entries.
///

pub struct DirectoryEntryMapper;

impl DirectoryEntryMapper {
    #[must_use]
    pub fn records_to_topology_entries(
        entries: &[DirectoryEntryRecord],
    ) -> Vec<TopologyDirectoryEntry> {
        entries
            .iter()
            .map(|entry| TopologyDirectoryEntry {
                role: entry.role.clone(),
                pid: entry.pid,
            })
            .collect()
    }
}