canic-core 0.110.36

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Passive fixture content, Store publication and exact target grant contracts.

use crate::ids::{ManagedCanisterBinding, ReleaseBuildId};
use candid::{CandidType, Principal};
use serde::{Deserialize, Serialize};

/// One independently decodable opaque chunk selected by an application descriptor.
#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct FixtureChunkDescriptor {
    pub digest: [u8; 32],
    pub length: u32,
}

/// Release-independent fixture content; release authority binds its resulting digest.
#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct FixtureDescriptor {
    pub schema_version: u16,
    pub format_hash: [u8; 32],
    pub encoded_length: u64,
    pub chunks: Vec<FixtureChunkDescriptor>,
    pub completion_summary: [u8; 32],
}

/// One bounded, sequential Store upload; exact earlier chunks may be replayed.
#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct FixtureChunkUpload {
    pub content_id: [u8; 32],
    pub index: u32,
    pub bytes: Vec<u8>,
}

/// Durable source-byte progress; completion is not an application data receipt.
#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct FixtureSourceStatus {
    pub content_id: [u8; 32],
    pub next_chunk: u32,
    pub chunk_count: u32,
    pub received_bytes: u64,
    pub complete: bool,
}

/// Root-derived installation authority independent of reusable content identity.
#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct FixtureTargetBinding {
    pub target: ManagedCanisterBinding,
    pub installation: [u8; 32],
    pub release_build_id: ReleaseBuildId,
    pub content_id: [u8; 32],
}

/// Compare-and-set read-grant intent; stale grant or revoke messages cannot replace it.
#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct FixtureGrantRequest {
    pub expected_revision: u64,
    pub binding: FixtureTargetBinding,
    pub enabled: bool,
}

/// Current target authority, including revoked revisions retained against stale replay.
#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct FixtureGrant {
    pub revision: u64,
    pub binding: FixtureTargetBinding,
    pub enabled: bool,
}

/// Authenticated target pull, pinned to the exact granted revision and content.
#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct FixtureChunkRead {
    pub grant: FixtureGrant,
    pub index: u32,
}

/// Closed Store outcomes for deterministic caller retry and conflict handling.
#[derive(CandidType, Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub enum FixtureStoreError {
    Authority,
    Bounds,
    Capacity,
    Conflict,
    Content,
    NotFound,
    NotReady,
    Sequence,
}

/// Immutable source selection installed by Root before the target can import data.
#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct FixtureAssignment {
    pub store: Principal,
    pub grant: FixtureGrant,
    pub descriptor: FixtureDescriptor,
}

/// Application-owned durable evidence of validated data for one exact installation.
#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct FixtureImportReceipt {
    pub binding: FixtureTargetBinding,
    pub completion_summary: [u8; 32],
}

/// Read-only projection of the application's sole durable import checkpoint.
#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct FixtureImportProgress {
    pub binding: FixtureTargetBinding,
    pub next_chunk: u32,
    pub receipt: Option<Box<FixtureImportReceipt>>,
}

/// Data prerequisite observed from protected selection and application-owned evidence.
#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub enum FixtureProvisioningStatus {
    NotRequired,
    AwaitingImporter,
    Pending(Option<Box<FixtureImportProgress>>),
    Complete(Box<FixtureImportReceipt>),
    Failed(FixtureImportFailure),
}

/// Closed consumer failures preserve source, transport and application diagnostic owners.
#[derive(CandidType, Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub enum FixtureImportError {
    Application { code: u32 },
    Authority,
    Busy,
    Codec(crate::dto::error::Error),
    ImporterMissing,
    NotReady,
    Progress,
    Receipt,
    Registration,
    Runtime(crate::dto::error::Error),
    Source(FixtureStoreError),
    SourceRejected(crate::dto::error::Error),
    Transport(crate::dto::error::Error),
}

/// Durable failure diagnostics retain the originating application or runtime owner.
pub use crate::domain::fixture_import::FixtureImportFailure;