Trait wasmcloud_interface_lattice_control::LatticeController

pub trait LatticeController {
    // Required methods
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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,
             Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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,
             Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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,
             Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    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 Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;

    // Provided method
    fn contract_id() -> &'static str { ... }
}

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. wasmbus.contractId: wasmcloud:latticecontrol wasmbus.providerReceive

Required Methods

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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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<CtlOperationAck>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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

Provided Methods

fn contract_id() -> &'static str

returns the capability contract id for this interface

Implementors

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