Struct Snapshot 

pub struct Snapshot {
    pub index: Index,
    pub term: Term,
    pub config: Vec<NodeId>,
    pub data: Vec<u8>,
}

A point-in-time capture of the application’s state machine, with the log position it covers.

A snapshot lets the log discard the entries it subsumes (compaction) and lets a leader catch up a follower that has fallen too far behind to replicate entry by entry. index and term are the last log entry the snapshot includes — its replacement “sentinel” once the entries up to there are gone — and data is the opaque serialized state the application produces and restores. The protocol moves the bytes but never interprets them.

Examples

use raft_io::Snapshot;

let snap = Snapshot::new(10, 3, b"serialized state".to_vec());
assert_eq!(snap.index, 10);
assert_eq!(snap.term, 3);

Fields

index: Index

Index of the last log entry the snapshot includes.

term: Term

Term of the last log entry the snapshot includes.

config: Vec<NodeId>

Voting membership in effect at index.

Carried so a node that catches up from this snapshot — its configuration log entries having been compacted away — still knows who is in the cluster. The node fills this in when it takes a snapshot; an application constructing a snapshot directly with new leaves it empty.

data: Vec<u8>

Opaque serialized state machine state. The protocol never inspects it.

Implementations

impl Snapshot

pub fn new(index: Index, term: Term, data: Vec<u8>) -> Self

Creates a snapshot covering the log through index (created in term), carrying serialized state data and an empty configuration.

The node fills the configuration in when it takes a snapshot; use this constructor for snapshots that do not track membership.

Examples

use raft_io::Snapshot;

let snap = Snapshot::new(5, 2, vec![1, 2, 3]);
assert_eq!(snap.data, vec![1, 2, 3]);
assert!(snap.config.is_empty());

pub fn with_config( index: Index, term: Term, config: Vec<NodeId>, data: Vec<u8>, ) -> Self

Creates a snapshot that also records the voting membership config in effect at index.

Examples

use raft_io::Snapshot;

let snap = Snapshot::with_config(5, 2, vec![1, 2, 3], vec![0xAB]);
assert_eq!(snap.config, vec![1, 2, 3]);

Trait Implementations

impl Clone for Snapshot

fn clone(&self) -> Snapshot

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Snapshot

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

Formats the value using the given formatter.

impl Deserialize for Snapshot

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 Snapshot

impl PartialEq for Snapshot

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

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 Snapshot