openraft 0.10.0-alpha.35

Advanced Raft consensus
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use std::fmt;

use openraft_macros::since;

use crate::Membership;
use crate::entry::RaftEntry;
use crate::entry::RaftPayload;
use crate::log_id::LogId;
use crate::vote::RaftCommittedLeaderId;

/// A Raft log entry.
#[since(version = "0.10.0", change = "from `Entry<CLID, D, NID, N>` to `Entry<CLID, P>`")]
#[since(version = "0.10.0", change = "from `Entry<C>` to `Entry<CLID, D, NID, N>`")]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize), serde(bound = ""))]
pub struct Entry<CLID, P>
where
    CLID: RaftCommittedLeaderId,
    P: RaftPayload,
{
    /// The log ID uniquely identifying this entry.
    pub log_id: LogId<CLID>,

    /// This entry's payload.
    pub payload: P,
}

impl<CLID, P> Clone for Entry<CLID, P>
where
    CLID: RaftCommittedLeaderId,
    P: RaftPayload + Clone,
{
    fn clone(&self) -> Self {
        Self {
            log_id: self.log_id.clone(),
            payload: self.payload.clone(),
        }
    }
}

impl<CLID, P> fmt::Debug for Entry<CLID, P>
where
    CLID: RaftCommittedLeaderId,
    P: RaftPayload,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Entry").field("log_id", &self.log_id).field("payload", &self.payload).finish()
    }
}

impl<CLID, P> PartialEq for Entry<CLID, P>
where
    CLID: RaftCommittedLeaderId,
    P: RaftPayload + PartialEq,
{
    fn eq(&self, other: &Self) -> bool {
        self.log_id == other.log_id && self.payload == other.payload
    }
}

impl<CLID, P> AsRef<Entry<CLID, P>> for Entry<CLID, P>
where
    CLID: RaftCommittedLeaderId,
    P: RaftPayload,
{
    fn as_ref(&self) -> &Entry<CLID, P> {
        self
    }
}

impl<CLID, P> fmt::Display for Entry<CLID, P>
where
    CLID: RaftCommittedLeaderId,
    P: RaftPayload,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}:{}", self.log_id, self.payload)
    }
}

impl<CLID, P> RaftEntry for Entry<CLID, P>
where
    CLID: RaftCommittedLeaderId,
    P: RaftPayload,
{
    type CommittedLeaderId = CLID;
    type Payload = P;

    fn new(log_id: LogId<CLID>, payload: P) -> Self {
        Self { log_id, payload }
    }

    fn log_id_parts(&self) -> (&CLID, u64) {
        (&self.log_id.leader_id, self.log_id.index)
    }

    fn set_log_id(&mut self, new: LogId<CLID>) {
        self.log_id = new;
    }

    fn get_membership(&self) -> Option<Membership<P::NodeId, P::Node>> {
        self.payload.get_membership()
    }
}