Trait paxakos::voting::Voter

pub trait Voter: Send + 'static {
    type State: State;
    type RoundNum: RoundNum;
    type CoordNum: CoordNum;
    type Yea: Debug + Send + Sync;
    type Nay: Debug + Send + Sync;
    type Abstain: Debug + Send + Sync;
    fn contemplate_candidate(
        &mut self, 
        round_num: Self::RoundNum, 
        coord_num: Self::CoordNum, 
        candidate: Option<&NodeOf<Self::State>>, 
        state: Option<&Self::State>
    ) -> Decision<(), Infallible, Self::Abstain>;
    fn contemplate_proposal(
        &mut self, 
        round_num: Self::RoundNum, 
        coord_num: Self::CoordNum, 
        log_entry: &LogEntryOf<Self::State>, 
        leader: Option<&NodeOf<Self::State>>, 
        state: Option<&Self::State>
    ) -> Decision<Self::Yea, Self::Nay, Infallible>;

    fn observe_commit(
        &mut self, 
        round_num: Self::RoundNum, 
        coord_num: Self::CoordNum, 
        log_entry: &LogEntryOf<Self::State>, 
        leader: Option<&NodeOf<Self::State>>
    ) { ... }
}

Strategy to vote on candidates and proposals.

Associated Types

type State: State

Type of shared state.

type RoundNum: RoundNum

Round number type.

type CoordNum: CoordNum

Coordination number type.

type Yea: Debug + Send + Sync

Data that will be added to any Yea vote on proposals.

type Nay: Debug + Send + Sync

Data that will be added to any Nay vote on proposals.

type Abstain: Debug + Send + Sync

Data that will be added to any Abstain from elections.

Required methods

fn contemplate_candidate(
    &mut self,
    round_num: Self::RoundNum,
    coord_num: Self::CoordNum,
    candidate: Option<&NodeOf<Self::State>>,
    state: Option<&Self::State>
) -> Decision<(), Infallible, Self::Abstain>

Contemplate a bid for leadership.

candidate will be None if the node cannot be inferred due to missing or outdated state.

Careful: state is the current applied state and independent of round_num.

fn contemplate_proposal(
    &mut self,
    round_num: Self::RoundNum,
    coord_num: Self::CoordNum,
    log_entry: &LogEntryOf<Self::State>,
    leader: Option<&NodeOf<Self::State>>,
    state: Option<&Self::State>
) -> Decision<Self::Yea, Self::Nay, Infallible>

Contemplate a proposed log entry.

leader will be None if the node cannot be inferred due to missing or outdated state.

Careful: state is the current applied state and independent of round_num.

Provided methods

fn observe_commit(
    &mut self,
    round_num: Self::RoundNum,
    coord_num: Self::CoordNum,
    log_entry: &LogEntryOf<Self::State>,
    leader: Option<&NodeOf<Self::State>>
)

Called for every commit.

leader will be None if the node cannot be inferred due to missing or outdated state.

Implementors

impl<S, R, C, A, Y, N> Voter for IndiscriminateVoter<S, R, C, A, Y, N> where
    S: State,
    R: RoundNum,
    C: CoordNum,
    A: Debug + Send + Sync + 'static,
    Y: Debug + Default + Send + Sync + 'static,
    N: Debug + Send + Sync + 'static, 

type State = S

type RoundNum = R

type CoordNum = C

type Yea = Y

type Nay = N

type Abstain = A

impl<S, V> Voter for GeneralLeaseGrantingVoter<S, V> where
    S: State,
    V: Voter<State = S>, 

type State = S

type RoundNum = RoundNumOf<V>

type CoordNum = CoordNumOf<V>

type Yea = (Duration, YeaOf<V>)

type Nay = NayOf<V>

type Abstain = Either<Duration, AbstainOf<V>>

impl<S, V> Voter for LeaseGrantingVoter<S, V> where
    S: State,
    V: Voter<State = S, Yea = (), Abstain = Infallible>, 

type State = S

type RoundNum = RoundNumOf<V>

type CoordNum = CoordNumOf<V>

type Yea = Duration

type Nay = NayOf<V>

type Abstain = Duration