Struct LicenceExchange 

pub struct LicenceExchange { /* private fields */ }

Receives, applies, forwards and syncs the licence records of one node.

Implementations

impl LicenceExchange

pub fn start(p: LicenceExchangeParts) -> Arc<Self>

Start the exchange: install the control sinks on the mesh (the kernel runtime or the service links) and begin the periodic and on-connect catch-up sync (when inside a tokio runtime).

pub fn approvals(&self) -> &Arc<ApprovalStore>

The node’s approval store (the run gate and weaver cog checkout status read it).

pub fn accept_binding( &self, env: &SignedBinding, spend: Spend, ) -> Result<Receipt, ExchangeError>

Cheap pre-verify filter and apply for a binding. spend picks the bucket (the operator’s own issue); see Spend.

pub fn accept_grant( &self, env: &SignedGrant, spend: Spend, ) -> Result<Receipt, ExchangeError>

Cheap pre-verify filter and apply for a grant.

pub fn accept_approval( &self, env: &SignedApproval, spend: Spend, ) -> Result<Receipt, ExchangeError>

Cheap pre-verify filter and apply for an approval.

pub async fn issue_binding( &self, env: SignedBinding, ) -> Result<Receipt, ExchangeError>

Accept a binding here (the operator’s own node, not rate limited) and send it to every peer. Used for a bind and for an unbind: any node with an operator key may issue one, so a steward cannot block it.

pub async fn issue_grant( &self, env: SignedGrant, ) -> Result<Receipt, ExchangeError>

As Self::issue_binding for a grant.

pub async fn issue_approval( &self, env: SignedApproval, ) -> Result<Receipt, ExchangeError>

As Self::issue_binding for an approval.

impl LicenceExchange

pub async fn sync_peer(&self, peer: &str)

Ask peer for its licence records. Does nothing while the local mesh id is unset, the peer is banned, or a request to it is still open.

pub async fn resync_all(&self)

Forget the requests in flight and ask every connected peer afresh: a node that just (re)gained the licence role, whose earlier requests the service refused, catches up at once.

pub async fn sync_all(&self)

Self::sync_peer with every connected peer.

Trait Implementations

impl GrantFlood for LicenceExchange

The steward relay floods the grants it obtains through the exchange (ADR-106 phase 1b over the 1c relay): same topic, budgets and admission as any other grant flood.

fn flood<'life0, 'life1, 'async_trait>( &'life0 self, grant: &'life1 SignedGrant, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Flood grant to the admitted peers. Best effort: the requester also gets the grant in its reply, and sync catches the rest up.