Struct PreVote 

pub struct PreVote {
    pub term: Term,
    pub candidate: NodeId,
    pub last_log_index: Index,
    pub last_log_term: Term,
}

A candidate’s pre-vote probe, sent before it commits to a real election.

Pre-voting (Raft thesis §9.6) is a disruption guard. Before a node increments its term and campaigns for real, it asks its peers whether they would vote for it at the next term — without bumping anyone’s term. A peer grants only if it has no active leader and the candidate’s log is up to date (the same election restriction a real vote applies). The candidate runs a real RequestVote election only once a quorum of pre-votes says yes.

The point is that a node partitioned away from the cluster never collects a pre-vote majority, so it never inflates its term. When it rejoins it does not force the established leader to step down, which is the disruption a plain election would cause. Unlike RequestVote, a pre-vote changes no persistent state on either side.

Examples

use raft_io::PreVote;

// The `term` is the *hypothetical* term the candidate would campaign at —
// one past its current term — not a term it has adopted.
let pv = PreVote { term: 5, candidate: 2, last_log_index: 9, last_log_term: 3 };
assert_eq!(pv.candidate, 2);

Fields

term: Term

The hypothetical term the candidate would campaign at — one past its current term. It is not a term the candidate has adopted; a recipient neither stores it nor steps down for it.

candidate: NodeId

The candidate seeking the pre-vote.

last_log_index: Index

Index of the candidate’s last log entry.

last_log_term: Term

Term of the candidate’s last log entry.

Trait Implementations

impl Clone for PreVote

fn clone(&self) -> PreVote

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PreVote

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deserialize for PreVote

fn deserialize<__D: Decode + ?Sized>(__decoder: &mut __D) -> Result<Self>

Read a value of Self from the decoder, advancing its cursor.

fn deserialize_many<D>( decoder: &mut D, count: usize, ) -> Result<Vec<Self>, SerialError>

where D: Decode + ?Sized,

Read count consecutive Self values into a freshly-allocated Vec.

impl Eq for PreVote

impl PartialEq for PreVote

fn eq(&self, other: &PreVote) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PreVote

fn serialize<__E: Encode + ?Sized>(&self, __encoder: &mut __E) -> Result<()>

Append the encoded bytes of self to encoder.

fn serialize_slice<E>( slice: &[Self], encoder: &mut E, ) -> Result<(), SerialError>

where E: Encode + ?Sized, Self: Sized,

Append the encoded bytes of every element of slice to encoder.

impl StructuralPartialEq for PreVote