paxakos 0.1.0

Rust implementation of Paxos consensus algorithm
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
104
105
106
107
108
109
110
111
112

use std::ops::RangeInclusive;
use std::sync::Arc;

use crate::error::{AcceptError, AffirmSnapshotError, CommitError, InstallSnapshotError};
use crate::error::{PrepareError, PrepareSnapshotError, ReadStaleError};
use crate::node::{Commit, Snapshot};
use crate::state::{LogEntryIdOf, LogEntryOf, NodeOf, State};
use crate::{CoordNum, Promise, RoundNum};

use super::error::{AcquireRoundNumError, ClusterError};
use super::RoundNumReservation;

#[derive(Debug)]
pub enum Request<S: State, R: RoundNum, C: CoordNum> {
    PrepareSnapshot,
    AffirmSnapshot {
        snapshot: Snapshot<S, R, C>,
    },
    InstallSnapshot {
        snapshot: Snapshot<S, R, C>,
    },

    ReadStale,

    AwaitCommitOf {
        entry_id: LogEntryIdOf<S>,
    },

    AcquireRoundNum {
        range: RangeInclusive<R>,
    },

    AcceptedEntryOf {
        round_num: R,
    },

    Cluster {
        round_num: R,
    },

    ObservedCoordNum {
        coord_num: C,
    },
    HighestObservedCoordNum,

    PrepareEntry {
        round_num: R,
        coord_num: C,
    },

    AcceptEntry {
        round_num: R,
        coord_num: C,
        entry: Arc<LogEntryOf<S>>,
    },
    AcceptEntries {
        coord_num: C,
        entries: Vec<(R, Arc<LogEntryOf<S>>)>,
    },

    CommitEntry {
        round_num: R,
        entry: Arc<LogEntryOf<S>>,
    },

    CommitEntryById {
        round_num: R,
        entry_id: LogEntryIdOf<S>,
    },

    ForceActive,

    Shutdown,
}

#[derive(Debug)]
pub enum Response<S: State, R: RoundNum, C: CoordNum> {
    PrepareSnapshot(Result<Snapshot<S, R, C>, PrepareSnapshotError>),
    AffirmSnapshot(Result<(), AffirmSnapshotError>),
    InstallSnapshot(Result<(), InstallSnapshotError>),

    ReadStale(Result<Arc<S>, ReadStaleError>),

    AwaitCommitOf(Result<Commit<S>, !>),

    AcquireRoundNum(Result<RoundNumReservation<R>, AcquireRoundNumError>),

    AcceptedEntryOf(Result<Option<Arc<LogEntryOf<S>>>, !>),

    Cluster(Result<Vec<NodeOf<S>>, ClusterError<R>>),

    ObservedCoordNum(Result<(), !>),
    HighestObservedCoordNum(Result<C, !>),

    PrepareEntry(Result<Promise<R, C, LogEntryOf<S>>, PrepareError<S, C>>),

    AcceptEntry(Result<(), AcceptError<S, C>>),
    AcceptEntries(Result<usize, AcceptError<S, C>>),

    CommitEntry(Result<(), CommitError<S>>),

    CommitEntryById(Result<(), CommitError<S>>),

    ForceActive(Result<bool, !>),

    Shutdown(Result<(), !>),
}

#[derive(Debug)]
pub enum Release<R: RoundNum> {
    RoundNum(R),
}