Trait wasmcloud_control_interface::LatticeController

source[−]
pub trait LatticeController {

Show 16 methods    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,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

    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: ToString + Sync + 'async_trait + ?Sized,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

    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,
        Self: 'async_trait;

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

}
Expand description

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

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.

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

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.

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

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

Instructs a given host to scale the indicated actor

Instructs a given host to start the indicated actor

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

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

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

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

Requests that the given host start the indicated capability provider

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

Requests that an actor be stopped on the given host

Requests that the given host be stopped

Provided methods

returns the capability contract id for this interface

Implementors