Struct InitializationValues

pub struct InitializationValues {
    pub compute_allocation: Option<PossiblyStr<u64>>,
    pub memory_allocation: Option<Byte>,
    pub freezing_threshold: Option<Duration>,
    pub reserved_cycles_limit: Option<u128>,
    pub wasm_memory_limit: Option<Byte>,
    pub log_visibility: Option<CanisterLogVisibility>,
}

Initial Resource Allocations

Fields

compute_allocation: Option<PossiblyStr<u64>>

Compute Allocation

Must be a number between 0 and 100, inclusively. It indicates how much compute power should be guaranteed to this canister, expressed as a percentage of the maximum compute power that a single canister can allocate.

memory_allocation: Option<Byte>

Memory Allocation

Maximum memory (in bytes) this canister is allowed to occupy. Can be specified as an integer, or as an SI unit string (e.g. “4KB”, “2 MiB”)

freezing_threshold: Option<Duration>

Freezing Threshold

Freezing threshould of the canister, measured in seconds. Valid inputs are numbers (seconds) or strings parsable by humantime (e.g. “15days 2min 2s”).

reserved_cycles_limit: Option<u128>

Reserved Cycles Limit

Specifies the upper limit of the canister’s reserved cycles balance.

Reserved cycles are cycles that the system sets aside for future use by the canister. If a subnet’s storage exceeds 450 GiB, then every time a canister allocates new storage bytes, the system sets aside some amount of cycles from the main balance of the canister. These reserved cycles will be used to cover future payments for the newly allocated bytes. The reserved cycles are not transferable and the amount of reserved cycles depends on how full the subnet is.

A setting of 0 means that the canister will trap if it tries to allocate new storage while the subnet’s memory usage exceeds 450 GiB.

wasm_memory_limit: Option<Byte>

Wasm Memory Limit

Specifies a soft limit (in bytes) on the Wasm memory usage of the canister.

Update calls, timers, heartbeats, installs, and post-upgrades fail if the Wasm memory usage exceeds this limit. The main purpose of this setting is to protect against the case when the canister reaches the hard 4GiB limit.

Must be a number of bytes between 0 and 2^48 (i.e. 256 TiB), inclusive. Can be specified as an integer, or as an SI unit string (e.g. “4KB”, “2 MiB”)

log_visibility: Option<CanisterLogVisibility>

Log Visibility

Specifies who is allowed to read the canister’s logs.

Can be “public”, “controllers” or “allowed_viewers” with a list of principals.

Trait Implementations

impl Clone for InitializationValues

fn clone(&self) -> InitializationValues

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InitializationValues

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for InitializationValues

fn default() -> InitializationValues

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for InitializationValues

where InitializationValues: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for InitializationValues

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl Serialize for InitializationValues

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.