Struct wasmcloud_interface_lattice_control::LatticeControllerSender

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

pub fn via(transport: T) -> Self

Constructs a LatticeControllerSender with the specified transport

pub fn set_timeout(&self, interval: Duration)

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, 'life2, 'async_trait, TS>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 TS
) -> Pin<Box<dyn Future<Output = RpcResult<Hosts>> + Send + 'async_trait>> where
    TS: 'async_trait + ToString + ?Sized + Sync,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: '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. The sole input to this query is the lattice ID on which the request takes place.

fn get_host_inventory<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 GetHostInventoryRequest
) -> Pin<Box<dyn Future<Output = RpcResult<HostInventory>> + Send + 'async_trait>> where
    '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, 'life2, 'async_trait, TS>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 TS
) -> Pin<Box<dyn Future<Output = RpcResult<GetClaimsResponse>> + Send + 'async_trait>> where
    TS: 'async_trait + ToString + ?Sized + Sync,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: '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. The sole input to this request is the lattice ID on which the request takes place.

fn scale_actor<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 ScaleActorCommand
) -> 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 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 = 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 AdvertiseLinkRequest
) -> 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, 'life2, 'async_trait, TS>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 TS
) -> Pin<Box<dyn Future<Output = RpcResult<LinkDefinitionList>> + Send + 'async_trait>> where
    TS: 'async_trait + ToString + ?Sized + Sync,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Queries all current link definitions in the specified 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 set_lattice_credentials<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 SetLatticeCredentialsRequest
) -> Pin<Box<dyn Future<Output = RpcResult<CtlOperationAck>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Instructs the provider to store the NATS credentials/URL for a given lattice. This is designed to allow a single capability provider (or multiple instances of the same) to manage multiple lattices, reducing overhead and making it easier to support secure multi-tenancy of lattices.

fn set_registry_credentials<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 SetRegistryCredentialsRequest
) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: '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 stop_host<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    ctx: &'life1 Context,
    arg: &'life2 StopHostCommand
) -> Pin<Box<dyn Future<Output = RpcResult<CtlOperationAck>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

fn contract_id() -> &'static str

returns the capability contract id for this interface