canic-host 0.93.5

Host-side build, install, deployment, and fleet-template library for Canic workspaces
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

//! Module: registry
//!
//! Responsibility: project typed subnet-registry responses into host registry entries.
//! Does not own: registry persistence, ICP command execution, or deployment topology policy.
//! Boundary: decodes the canonical ICP envelope and validates redundant registry identity fields.

#[cfg(test)]
mod tests;

use crate::icp::{IcpJsonResponseError, decode_json_result_response};
use canic_core::{
    cdk::utils::hash::hex_bytes,
    dto::topology::{SubnetRegistryEntry, SubnetRegistryResponse},
};
use thiserror::Error as ThisError;

///
/// RegistryEntry
///

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct RegistryEntry {
    pub pid: String,
    pub role: Option<String>,
    pub parent_pid: Option<String>,
    pub module_hash: Option<String>,
}

///
/// RegistryParseError
///

#[derive(Debug, ThisError)]
pub enum RegistryParseError {
    #[error("registry entry principal mismatch: entry={entry_pid} record={record_pid}")]
    PrincipalMismatch {
        entry_pid: String,
        record_pid: String,
    },

    #[error(transparent)]
    Response(#[from] IcpJsonResponseError),

    #[error("registry entry role mismatch for {pid}: entry={entry_role} record={record_role}")]
    RoleMismatch {
        pid: String,
        entry_role: String,
        record_role: String,
    },
}

/// Decode and validate one canonical ICP subnet-registry response.
pub fn parse_registry_entries(
    registry_json: &str,
) -> Result<Vec<RegistryEntry>, RegistryParseError> {
    let response = decode_json_result_response::<SubnetRegistryResponse>(registry_json)?;
    registry_entries_from_response(response)
}

/// Validate and project one typed subnet-registry response.
pub(crate) fn registry_entries_from_response(
    response: SubnetRegistryResponse,
) -> Result<Vec<RegistryEntry>, RegistryParseError> {
    response.0.into_iter().map(registry_entry).collect()
}

fn registry_entry(entry: SubnetRegistryEntry) -> Result<RegistryEntry, RegistryParseError> {
    let pid = entry.pid.to_text();
    let record_pid = entry.record.pid.to_text();
    if pid != record_pid {
        return Err(RegistryParseError::PrincipalMismatch {
            entry_pid: pid,
            record_pid,
        });
    }

    let role = entry.role.into_string();
    let record_role = entry.record.role.into_string();
    if role != record_role {
        return Err(RegistryParseError::RoleMismatch {
            pid,
            entry_role: role,
            record_role,
        });
    }

    Ok(RegistryEntry {
        pid,
        role: Some(role),
        parent_pid: entry.record.parent_pid.map(|pid| pid.to_text()),
        module_hash: entry.record.module_hash.map(hex_bytes),
    })
}