Enum Message 

#[non_exhaustive]
pub enum Message {
    PreVote(PreVote),
    PreVoteReply(PreVoteReply),
    RequestVote(RequestVote),
    RequestVoteReply(RequestVoteReply),
    AppendEntries(AppendEntries),
    AppendEntriesReply(AppendEntriesReply),
    InstallSnapshot(InstallSnapshot),
    InstallSnapshotReply(InstallSnapshotReply),
    TimeoutNow(TimeoutNow),
}

Any message a node can send or receive.

Wraps the RPCs and their replies. The enum is #[non_exhaustive]: future versions may add variants, so a match over a Message must include a wildcard arm.

Examples

use raft_io::{Message, RequestVote};

let msg = Message::RequestVote(RequestVote {
    term: 1,
    candidate: 1,
    last_log_index: 0,
    last_log_term: 0,
    force: false,
});
match msg {
    Message::RequestVote(rv) => assert_eq!(rv.term, 1),
    _ => unreachable!(),
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

PreVote(PreVote)

A candidate is probing for support before a real election.

PreVoteReply(PreVoteReply)

A peer is answering a pre-vote probe.

RequestVote(RequestVote)

A candidate is asking for a vote.

RequestVoteReply(RequestVoteReply)

A peer is answering a vote request.

AppendEntries(AppendEntries)

A leader is replicating entries or sending a heartbeat.

AppendEntriesReply(AppendEntriesReply)

A follower is answering an append.

InstallSnapshot(InstallSnapshot)

A leader is shipping a snapshot to a far-behind follower.

InstallSnapshotReply(InstallSnapshotReply)

A follower is acknowledging an installed snapshot.

TimeoutNow(TimeoutNow)

A leader is handing off leadership, telling the target to campaign now.

Implementations

impl Message

pub fn term(&self) -> Term

Returns the term carried by the message, whatever its variant.

The protocol checks the term of every inbound message first — a higher term forces the node to step down — so a single accessor avoids matching at each call site.

Examples

use raft_io::{AppendEntriesReply, Message};

let m = Message::AppendEntriesReply(AppendEntriesReply {
    term: 5,
    success: false,
    from: 2,
    match_index: 0,
    conflict_index: 1,
    conflict_term: 0,
});
assert_eq!(m.term(), 5);

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl Deserialize for Message

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 Message

impl PartialEq for Message

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

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 Message