Struct Server 

pub struct Server<T: NodeType> {
    public_key: T::SignatureKey,
    blocks: BTreeMap<ViewNumber, RetainedBlock>,
    locked: Option<ViewNumber>,
    timed_out: Option<ViewNumber>,
}

The serving half of payload recovery.

What a stalled peer asks for is the payload of the view the quorum is locked at, so that is what this keeps, and locked names it. Payloads arrive before the certificate that moves the lock onto them, and in a stall later views keep reconstructing while every lock stays put, so a few of the most recent are held as candidates until one of them is locked.

Fields

public_key: T::SignatureKey

blocks: BTreeMap<ViewNumber, RetainedBlock>

The blocks we can serve, newest last.

locked: Option<ViewNumber>

The view we are locked at, whose block is never evicted.

timed_out: Option<ViewNumber>

The last view the network timed out on, which is what makes us willing to serve at all.

Implementations

impl<T: NodeType> Server<T>

pub fn new(public_key: T::SignatureKey) -> Self

pub fn retain( &mut self, view: ViewNumber, payload_commitment: VidCommitment2, payload: &T::BlockPayload, )

Hold on to a freshly obtained block, evicting the earliest one we no longer need.

Which of the retained blocks the lock will land on is not known yet: payloads arrive before the certificates that move the lock onto them, and decoding several views can finish out of order. Keeping the last few means the one the lock reaches is still here when it does.

pub fn lock_moved(&mut self, view: ViewNumber)

Follow our lock to view, so that view’s block is the one kept.

A lock only ever moves to a view we reconstructed, so we normally hold its block. We do not when the certificate arrived so late that the block was evicted, and then this node serves nothing for its lock until the lock moves again.

pub fn view_timed_out(&mut self, view: ViewNumber)

Note that the network timed out on view.

pub fn handle_request( &self, request: &PayloadFetchRequest, sender: &T::SignatureKey, slot: ViewNumber, network: &Sender<T>, ) -> Result<(), CoordinatorError>

Unicast the retained block to sender if that is what request asks for.

fn respond( &self, view: ViewNumber, body: PayloadResponseBody, sender: &T::SignatureKey, slot: ViewNumber, network: &Sender<T>, ) -> Result<(), CoordinatorError>

fn serving(&self, current_view: ViewNumber) -> bool

Whether a payload fetch is plausible right now.