Struct AppendEntries 

pub struct AppendEntries {
    pub term: Term,
    pub leader: NodeId,
    pub prev_log_index: Index,
    pub prev_log_term: Term,
    pub entries: Vec<LogEntry>,
    pub leader_commit: Index,
}

The leader’s replicate-and-heartbeat RPC.

The leader sends this to each follower. With an empty entries list it is a pure heartbeat that asserts leadership and resets the follower’s election timer; with entries it replicates the log (from v0.3). The prev_log_index / prev_log_term pair lets the follower verify its log matches the leader’s up to that point before accepting anything new.

Examples

use raft_io::AppendEntries;

// An empty heartbeat for term 4 from node 1.
let hb = AppendEntries {
    term: 4,
    leader: 1,
    prev_log_index: 9,
    prev_log_term: 3,
    entries: Vec::new(),
    leader_commit: 7,
};
assert!(hb.entries.is_empty());

Fields

term: Term

The leader’s term.

leader: NodeId

The leader sending the RPC, so followers can record it.

prev_log_index: Index

Index of the log entry immediately preceding the new ones.

prev_log_term: Term

Term of the entry at prev_log_index.

entries: Vec<LogEntry>

Entries to store (empty for a heartbeat). Replication uses this in v0.3.

leader_commit: Index

The leader’s commit index, so followers can advance their own.

Trait Implementations

impl Clone for AppendEntries

fn clone(&self) -> AppendEntries

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AppendEntries

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

Formats the value using the given formatter.

impl Deserialize for AppendEntries

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 AppendEntries

impl PartialEq for AppendEntries

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

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 AppendEntries