Struct EpochMembershipCoordinator

pub struct EpochMembershipCoordinator<TYPES: NodeType> {
    membership: Arc<RwLock<TYPES::Membership>>,
    catchup_map: Arc<Mutex<HashMap<<TYPES as NodeType>::Epoch, InactiveReceiver<Result<EpochMembership<TYPES>>>>>>,
    storage_add_drb_result_fn: Option<StorageAddDrbResultFn<TYPES>>,
    pub epoch_height: u64,
    store_drb_progress_fn: StoreDrbProgressFn,
}

Struct to Coordinate membership catchup

Fields

membership: Arc<RwLock<TYPES::Membership>>

The underlying membhersip

catchup_map: Arc<Mutex<HashMap<<TYPES as NodeType>::Epoch, InactiveReceiver<Result<EpochMembership<TYPES>>>>>>

Any in progress attempts at catching up are stored in this map Any new callers wantin an EpochMembership will await on the signal alerting them the membership is ready. The first caller for an epoch will wait for the actual catchup and allert future callers when it’s done

storage_add_drb_result_fn: Option<StorageAddDrbResultFn<TYPES>>

Callback function to store a drb result when one is calculated during catchup

epoch_height: u64

Number of blocks in an epoch

store_drb_progress_fn: StoreDrbProgressFn

Implementations

impl<TYPES: NodeType> EpochMembershipCoordinator<TYPES>

where Self: Send,

pub fn new<S: Storage<TYPES>>( membership: Arc<RwLock<TYPES::Membership>>, epoch_height: u64, storage: &S, ) -> Self

Create an EpochMembershipCoordinator

pub fn membership(&self) -> &Arc<RwLock<TYPES::Membership>>

Get a reference to the membership

pub async fn membership_for_epoch( &self, maybe_epoch: Option<TYPES::Epoch>, ) -> Result<EpochMembership<TYPES>>

Get a Membership for a given Epoch, which is guaranteed to have a randomized stake table for the given Epoch

pub async fn stake_table_for_epoch( &self, maybe_epoch: Option<TYPES::Epoch>, ) -> Result<EpochMembership<TYPES>>

Get a Membership for a given Epoch, which is guaranteed to have a stake table for the given Epoch

async fn catchup(self, epoch: TYPES::Epoch) -> Result<EpochMembership<TYPES>>

Catches the membership up to the epoch passed as an argument.
To do this try to get the stake table for the epoch containing this epoch’s root if the root does not exist recursively catchup until you’ve found it

If there is another catchup in progress this will not duplicate efforts e.g. if we start with only epoch 0 stake table and call catchup for epoch 10, then call catchup for epoch 20 the first caller will actually do the work for to catchup to epoch 10 then the second caller will continue catching up to epoch 20

pub async fn wait_for_catchup( &self, epoch: TYPES::Epoch, ) -> Result<EpochMembership<TYPES>>

Trait Implementations

impl<TYPES: NodeType> Clone for EpochMembershipCoordinator<TYPES>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.