Struct InstallChunkedCodeBuilder 

pub struct InstallChunkedCodeBuilder<'agent, 'canister> { /* private fields */ }

A builder for an install_chunked_code call.

Implementations

impl<'agent: 'canister, 'canister> InstallChunkedCodeBuilder<'agent, 'canister>

pub fn builder( canister: &'canister Canister<'agent>, target_canister: Principal, wasm_module_hash: &[u8], ) -> Self

Create an InstallChunkedCodeBuilder.

pub fn with_chunk_hashes(self, chunk_hashes: Vec<ChunkHash>) -> Self

Set the chunks to install. These must previously have been set with ManagementCanister::upload_chunk.

pub fn with_store_canister(self, store_canister: Principal) -> Self

Set the canister to pull uploaded chunks from. By default this is the same as the target canister.

pub fn with_arg(self, argument: impl CandidType) -> Self

Set the argument to the installation, which will be passed to the init method of the canister. Can be called at most once.

pub fn with_args(self, argument: impl ArgumentEncoder) -> Self

Set the argument with multiple arguments as tuple to the installation, which will be passed to the init method of the canister. Can be called at most once.

pub fn with_raw_arg(self, argument: Vec<u8>) -> Self

Set the argument passed in to the canister with raw bytes. Can be called at most once.

pub fn with_install_mode(self, mode: CanisterInstallMode) -> Self

Set the CanisterInstallMode.

pub fn build(self) -> Result<impl 'agent + AsyncCall<Value = ()>, AgentError>

Create an AsyncCall implementation that, when called, will install the canister.

pub async fn call(self) -> Result<CallResponse<()>, AgentError>

Make the call. This is equivalent to AsyncCall::call.

pub async fn call_and_wait(self) -> Result<(), AgentError>

Make the call. This is equivalent to AsyncCall::call_and_wait.

Trait Implementations

impl<'agent, 'canister: 'agent> AsyncCall for InstallChunkedCodeBuilder<'agent, 'canister>

type Value = ()

The return type of the Candid function being called.

fn call<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = Result<CallResponse<()>, AgentError>> + 'async_trait>>

where Self: 'async_trait,

Execute the call, but returns the RequestId. Waiting on the request Id must be managed by the caller using the Agent directly.

fn call_and_wait<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = Result<(), AgentError>> + 'async_trait>>

where Self: 'async_trait,

Execute the call, and wait for an answer using an exponential-backoff strategy. The return type is encoded in the trait.

fn and_then<'a, Out2, R, AndThen>( self, and_then: AndThen, ) -> AndThenAsyncCaller<'a, Self::Value, Out2, Self, R, AndThen>

where Self: Sized + Send + 'a, Out2: for<'de> ArgumentDecoder<'de> + Send + 'a, R: Future<Output = Result<Out2, AgentError>> + Send + 'a, AndThen: Send + Fn(Self::Value) -> R + 'a,

Apply a transformation function after the call has been successful. The transformation is applied with the result.

fn map<'a, Out, Map>( self, map: Map, ) -> MappedAsyncCaller<'a, Self::Value, Out, Self, Map>

where Self: Sized + Send + 'a, Out: for<'de> ArgumentDecoder<'de> + Send + 'a, Map: Send + Fn(Self::Value) -> Out + 'a,

Apply a transformation function after the call has been successful. Equivalent to .and_then(|x| async { map(x) }).

impl<'agent, 'canister> Debug for InstallChunkedCodeBuilder<'agent, 'canister>

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

Formats the value using the given formatter.

impl<'agent, 'canister: 'agent> IntoFuture for InstallChunkedCodeBuilder<'agent, 'canister>

type IntoFuture = Pin<Box<dyn Future<Output = Result<(), AgentError>> + 'agent>>

Which kind of future are we turning this into?

type Output = Result<(), AgentError>

The output that the future will produce on completion.

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.