Struct wasmcloud_interface_lattice_control::LatticeControllerSender

pub struct LatticeControllerSender<T: Transport> { /* fields omitted */ }

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: Transport> LatticeControllerSender<T>

pub fn via(transport: T) -> Self

Constructs a LatticeControllerSender with the specified transport

Trait Implementations

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

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

Formats the value using the given formatter.

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

fn auction_provider<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 ProviderAuctionRequest
) -> Pin<Box<dyn Future<Output = RpcResult<ProviderAuctionAcks>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: '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 = RpcResult<ActorAuctionAcks>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: '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 = RpcResult<Hosts>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: '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: ToString + ?Sized + Sync>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 TS
) -> Pin<Box<dyn Future<Output = RpcResult<HostInventory>> + Send + 'async_trait>> where
    TS: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: '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 = RpcResult<GetClaimsResponse>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: '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 start_actor<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 StartActorCommand
) -> Pin<Box<dyn Future<Output = RpcResult<CtlOperationAck>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: '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 = RpcResult<CtlOperationAck>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: '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 = RpcResult<CtlOperationAck>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: '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 = RpcResult<LinkDefinitionList>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: '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 = RpcResult<CtlOperationAck>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: '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 = RpcResult<CtlOperationAck>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: '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 = RpcResult<CtlOperationAck>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: '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 = RpcResult<CtlOperationAck>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: '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 = RpcResult<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Requests that the given host be stopped