canic-core 0.110.22

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

//! Module: ops
//!
//! Responsibility: expose deterministic state access and approved single-step platform effects.
//! Does not own: endpoint authentication, workflow orchestration, or pure policy decisions.
//! Boundary: workflow calls ops after authorization; ops accesses model-owned state.
//!
//! Ops APIs are exposed via lightweight `*Ops` structs with associated
//! functions. This is a deliberate namespacing choice to keep imports stable
//! and unambiguous in large modules where multiple `env`, `config`, or
//! `storage` modules may coexist.
//!
//! The use of `*Ops` types does **not** imply ownership of state or additional
//! abstraction; they are zero-cost namespaces over free functions.

pub mod auth;
#[cfg(feature = "blob-storage")]
pub mod blob_storage;
pub mod cascade;
pub mod cascade_report;
#[cfg(feature = "blob-storage-billing")]
pub mod cashier;
pub mod component_provisioning_plan;
pub mod component_provisioning_receipt;
pub mod component_runtime;
pub mod config;
pub mod cost_guard;
pub mod fixture_content;
pub mod fixture_importer;
pub mod fleet_activation;
pub mod fleet_admission_policy;
pub mod fleet_funding_policy;
pub mod fleet_registry;
pub mod fleet_service_binding;
pub mod ic;
pub mod placement;
pub mod replay;
pub mod root_draining_reservation;
pub mod rpc;
pub mod runtime;
pub mod storage;

///
/// Prelude
///
/// Common ops imports for modules that need boundary and diagnostic types.
///

pub mod prelude {
    pub use crate::{
        cdk::{
            candid::CandidType,
            types::{Cycles, Principal},
        },
        ids::CanisterRole,
        log,
        log::Topic,
    };
}

use crate::InternalError;
use thiserror::Error as ThisError;

///
/// OpsError
///
/// Ops public APIs return `Result<_, InternalError>`.
/// Ops-scoped error enums stay internal so the public error surface remains uniform.
///

#[derive(Debug, ThisError)]
pub enum OpsError {
    #[error(transparent)]
    ConfigOps(#[from] config::ConfigOpsError),

    #[error(transparent)]
    ComponentProvisioningPlan(
        #[from] component_provisioning_plan::ComponentProvisioningPlanOpsError,
    ),

    #[error(transparent)]
    FleetRegistry(#[from] fleet_registry::FleetRegistryOpsError),

    #[error(transparent)]
    FleetServiceBinding(#[from] fleet_service_binding::FleetServiceBindingOpsError),

    #[error(transparent)]
    IcInfra(#[from] crate::infra::ic::IcInfraError),

    #[error(transparent)]
    RpcOps(#[from] rpc::RpcOpsError),

    #[error(transparent)]
    RuntimeOps(#[from] runtime::RuntimeOpsError),

    #[error(transparent)]
    StorageOps(#[from] storage::StorageOpsError),
}

impl From<OpsError> for InternalError {
    fn from(err: OpsError) -> Self {
        match err {
            OpsError::ConfigOps(err) => err.into(),
            OpsError::IcInfra(err) => err.into(),
            OpsError::RpcOps(err) => err.into(),
            OpsError::RuntimeOps(err) => err.into(),
            OpsError::StorageOps(err) => err.into(),
            OpsError::ComponentProvisioningPlan(_)
            | OpsError::FleetRegistry(_)
            | OpsError::FleetServiceBinding(_) => {
                Self::public(crate::diagnostics::codes::STATE_FAILED)
            }
        }
    }
}