Struct wasmcloud_control_interface::LatticeControllerSender

pub struct LatticeControllerSender<T> where
    T: Transport,  { /* private fields */ }

LatticeControllerSender sends messages to a LatticeController service Lattice Controller - Describes the interface used for actors to communicate with a lattice controller, enabling developers to deploy actors that can manipulate the lattice in which they’re running. client for sending LatticeController messages

Implementations

impl<T> LatticeControllerSender<T> where
    T: Transport, 

pub fn via(transport: T) -> LatticeControllerSender<T>

Constructs a LatticeControllerSender with the specified transport

pub fn set_timeout(&self, interval: Duration)

Trait Implementations

impl<T> Debug for LatticeControllerSender<T> where
    T: Debug + Transport, 

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

Formats the value using the given formatter.

impl<T> LatticeController for LatticeControllerSender<T> where
    T: Transport + Sync + Send, 

fn auction_provider<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 ProviderAuctionRequest
) -> Pin<Box<dyn Future<Output = Result<Vec<ProviderAuctionAck, Global>, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Seek out a list of suitable hosts for a capability provider given a set of host label constraints. Hosts on which this provider is already running will not be among the successful “bidders” in this auction.

fn auction_actor<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 ActorAuctionRequest
) -> Pin<Box<dyn Future<Output = Result<Vec<ActorAuctionAck, Global>, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Seek out a list of suitable hosts for an actor given a set of host label constraints.

fn get_hosts<'life0, 'life1, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context
) -> Pin<Box<dyn Future<Output = Result<Vec<Host, Global>, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Queries the list of hosts currently visible to the lattice. This is a “gather” operation and so can be influenced by short timeouts, network partition events, etc.

fn get_host_inventory<'life0, 'life1, 'life2, 'async_trait, TS>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 TS
) -> Pin<Box<dyn Future<Output = Result<HostInventory, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    TS: 'async_trait + ToString + Sync + ?Sized,
    LatticeControllerSender<T>: 'async_trait, 

Queries for the contents of a host given the supplied 56-character unique ID

fn get_claims<'life0, 'life1, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context
) -> Pin<Box<dyn Future<Output = Result<GetClaimsResponse, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Queries the lattice for the list of known/cached claims by taking the response from the first host that answers the query.

fn scale_actor<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 ScaleActorCommand
) -> Pin<Box<dyn Future<Output = Result<CtlOperationAck, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Instructs a given host to scale the indicated actor

fn start_actor<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 StartActorCommand
) -> Pin<Box<dyn Future<Output = Result<CtlOperationAck, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Instructs a given host to start the indicated actor

fn advertise_link<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 LinkDefinition
) -> Pin<Box<dyn Future<Output = Result<CtlOperationAck, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Publish a link definition into the lattice, allowing it to be cached and delivered to the appropriate capability provider instances

fn remove_link<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 RemoveLinkDefinitionRequest
) -> Pin<Box<dyn Future<Output = Result<CtlOperationAck, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Requests the removal of a link definition. The definition will be removed from the cache and the relevant capability providers will be given a chance to de-provision any used resources

fn get_links<'life0, 'life1, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context
) -> Pin<Box<dyn Future<Output = Result<LinkDefinitionList, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Queries all current link definitions in the lattice. The first host that receives this response will reply with the contents of the distributed cache

fn update_actor<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 UpdateActorCommand
) -> Pin<Box<dyn Future<Output = Result<CtlOperationAck, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Requests that a specific host perform a live update on the indicated actor

fn start_provider<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 StartProviderCommand
) -> Pin<Box<dyn Future<Output = Result<CtlOperationAck, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Requests that the given host start the indicated capability provider

fn stop_provider<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 StopProviderCommand
) -> Pin<Box<dyn Future<Output = Result<CtlOperationAck, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Requests that the given capability provider be stopped on the indicated host

fn stop_actor<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 StopActorCommand
) -> Pin<Box<dyn Future<Output = Result<CtlOperationAck, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Requests that an actor be stopped on the given host

fn stop_host<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 StopHostCommand
) -> Pin<Box<dyn Future<Output = Result<CtlOperationAck, RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Requests that the given host be stopped

fn set_registry_credentials<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 HashMap<String, RegistryCredential, RandomState>
) -> Pin<Box<dyn Future<Output = Result<(), RpcError>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    LatticeControllerSender<T>: 'async_trait, 

Instructs all listening hosts to use the enclosed credential map for authentication to secure artifact (OCI/bindle) registries. Any host that receives this message will delete its previous credential map and replace it with the enclosed. The credential map for a lattice can be purged by sending this message with an empty map

fn contract_id() -> &'static str

returns the capability contract id for this interface