Struct AppendEntriesReply 

pub struct AppendEntriesReply {
    pub term: Term,
    pub success: bool,
    pub from: NodeId,
    pub match_index: Index,
    pub conflict_index: Index,
    pub conflict_term: Term,
}

A follower’s response to an AppendEntries.

success is true when the follower’s log matched at prev_log_index and it accepted the RPC. match_index reports the highest log index the follower now agrees on, which the leader uses to track replication progress.

On a rejection, the conflict_* fields let the leader skip the follower’s next_index back by a whole term in one round trip instead of decrementing one entry at a time (the fast-backtracking optimisation from the Raft thesis, §5.3). They are 0 on success and ignored.

Examples

use raft_io::AppendEntriesReply;

let ok = AppendEntriesReply {
    term: 4,
    success: true,
    from: 2,
    match_index: 9,
    conflict_index: 0,
    conflict_term: 0,
};
assert!(ok.success);

Fields

term: Term

The follower’s current term, for the leader to update itself.

success: bool

Whether the follower accepted the RPC.

from: NodeId

The node that produced this reply.

match_index: Index

Highest log index the follower now matches with the leader.

conflict_index: Index

On rejection, the index the leader should probe next (the follower’s first index of conflict_term, or its log length plus one when the log is simply too short). 0 on success.

conflict_term: Term

On rejection, the term of the follower’s entry at prev_log_index, or 0 when the follower has no entry there. 0 on success.

Trait Implementations

impl Clone for AppendEntriesReply

fn clone(&self) -> AppendEntriesReply

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AppendEntriesReply

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

Formats the value using the given formatter.

impl Deserialize for AppendEntriesReply

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 AppendEntriesReply

impl PartialEq for AppendEntriesReply

fn eq(&self, other: &AppendEntriesReply) -> 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 AppendEntriesReply

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 AppendEntriesReply