canic-core 0.110.54

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

//! Module: workflow::caller_authority
//!
//! Protected receiver publication orchestration after endpoint authentication.

pub mod admission;

use crate::{
    InternalError,
    config::caller_authority::CompiledCallerPolicy,
    domain::policy::pure::caller_authority::matches_permission,
    dto::caller_authority::{
        CallerAuthorityCommand, CallerAuthorityReceipt, CallerAuthorityStatus,
    },
    model::caller_authority::{
        CallerChangeRecord, CallerPublicationError, CallerPublicationRecord, CallerReceiptRecord,
    },
    ops::{caller_authority::CallerAuthorityOps, config::ConfigOps},
};

pub fn apply(command: CallerAuthorityCommand) -> Result<CallerAuthorityReceipt, InternalError> {
    let receipt = match command {
        CallerAuthorityCommand::Prepare(publication) => ConfigOps::with_caller_policy(|policy| {
            prepare(
                CallerAuthorityOps::publication_from_dto(publication),
                policy,
            )
        })?,
        CallerAuthorityCommand::Commit(publication) => {
            CallerAuthorityOps::commit(&CallerAuthorityOps::publication_from_dto(publication))
        }
        CallerAuthorityCommand::Complete(publication) => {
            CallerAuthorityOps::complete(&CallerAuthorityOps::publication_from_dto(publication))
        }
    }
    .map_err(publication_error)?;
    Ok(CallerAuthorityOps::receipt_to_dto(receipt))
}

/// Decide source eligibility before the storage owner reserves and persists a publication.
pub fn prepare(
    publication: CallerPublicationRecord,
    policy: &CompiledCallerPolicy,
) -> Result<CallerReceiptRecord, CallerPublicationError> {
    let source_permitted = match &publication.change {
        CallerChangeRecord::StageSource(source) | CallerChangeRecord::Grant(source) => {
            policy.configuration.as_ref().is_some_and(|config| {
                config.permissions.keys().any(|permission| {
                    matches_permission(policy, permission, &publication.authority.receiver, source)
                })
            })
        }
        _ => true,
    };
    CallerAuthorityOps::prepare(publication, policy, source_permitted)
}

pub fn publication(
    authority: crate::ids::CallerReceiverAuthority,
    operation_id: [u8; 32],
    previous_generation: u64,
    change: crate::dto::caller_authority::CallerAuthorityChange,
) -> Result<crate::dto::caller_authority::CallerAuthorityPublication, InternalError> {
    CallerAuthorityOps::build_publication(authority, operation_id, previous_generation, change)
        .map_err(publication_error)
}

pub fn status(operation_id: [u8; 32]) -> Result<CallerAuthorityStatus, InternalError> {
    let receiver = CallerAuthorityOps::receiver().ok_or_else(InternalError::unavailable)?;
    let mut status =
        CallerAuthorityOps::status_to_dto(receiver, CallerAuthorityOps::receipt(operation_id));
    if status.readiness == crate::dto::caller_authority::CallerAuthorityReadiness::ApplicationReady
        && !crate::workflow::fixture_provisioning::is_ready(
            &crate::workflow::fixture_provisioning::status(),
        )
    {
        status.readiness = crate::dto::caller_authority::CallerAuthorityReadiness::FrameworkReady;
    }
    Ok(status)
}

pub(in crate::workflow) const fn publication_error(error: CallerPublicationError) -> InternalError {
    use crate::diagnostics::codes;
    InternalError::public(match error {
        CallerPublicationError::AuthorityConflict => codes::AUTHORITY_CONFLICT,
        CallerPublicationError::Capacity => codes::STATE_CAPACITY,
        CallerPublicationError::InProgress => codes::STATE_UNAVAILABLE,
        CallerPublicationError::InvalidPublication => codes::STATE_INVALID,
        CallerPublicationError::Retired => codes::AUTHORITY_INACTIVE,
        CallerPublicationError::GenerationConflict
        | CallerPublicationError::PhaseConflict
        | CallerPublicationError::ReplayConflict => codes::STATE_CONFLICT,
    })
}