raft-log 0.4.4

Raft log implementation
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

//! Core type definitions for the Raft-log implementation.
//!
//! This module defines the `Types` trait which serves as a type system for the
//! entire Raft-log implementation. It allows users to customize core data types
//! such as log id, log payload, vote, callback, and user data.

use std::fmt::Debug;
use std::marker::PhantomData;

use chunked_wal::Callback;
use codeq::Codec;

use crate::RaftLogAction;
use crate::WalTypes;
use crate::raft_log::state_machine::raft_log_state::RaftLogState;

/// The `Types` trait defines the core type parameters used throughout the
/// Raft-log implementation.
///
/// This trait provides an abstraction layer for the log implementation by
/// defining the core types used throughout the system. Implementations can
/// customize the concrete types for: log id, log payload, vote, callback, and
/// user data.
pub trait Types
where Self: Debug + Default + PartialEq + Eq + Clone + 'static
{
    /// Unique identifier for log entries. Usually it contains the term and log
    /// index.
    type LogId: Debug + Clone + Ord + Eq + Codec + Send + Sync + 'static;

    /// The actual data/command stored in log entries.
    type LogPayload: Debug + Clone + Codec + Send + Sync + 'static;

    /// Representation of vote in leader election.
    ///
    /// A vote typically contains:
    /// - The election term number
    /// - The candidate node ID
    /// - A commitment flag indicating whether a quorum of nodes has granted
    ///   this vote
    ///
    /// The commitment flag is set to true when a majority of nodes in the
    /// cluster have voted for this candidate in this term.
    ///
    /// In some raft implementation the vote is called `hard state`
    type Vote: Debug + Clone + PartialOrd + Eq + Codec + Send + Sync + 'static;

    /// Callback handlers for notification of an IO operation.
    type Callback: Callback;

    /// Custom data that can be attached to Raft-log.
    ///
    /// This data is not used by the Raft-log implementation, but it can be used
    /// by the user. For example, an application could attach a
    /// configuration or the node info in this field.
    type UserData: Debug + Clone + Eq + Codec + Send + Sync + 'static;

    /// Get the log index from the log id.
    fn log_index(log_id: &Self::LogId) -> u64;

    /// Get the payload size from the log payload.
    ///
    /// The returned size does not have to be accurate. It is only used to
    /// estimate the space occupied in the cache.
    fn payload_size(payload: &Self::LogPayload) -> u64;

    /// Get the next log index from the log id.
    fn next_log_index(log_id: Option<&Self::LogId>) -> u64 {
        match log_id {
            Some(log_id) => Self::log_index(log_id) + 1,
            None => 0,
        }
    }
}

#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub struct RaftWalTypes<T>(PhantomData<T>);

impl<T> WalTypes for RaftWalTypes<T>
where T: Types
{
    type Action = RaftLogAction<T>;
    type Checkpoint = RaftLogState<T>;
    type Callback = T::Callback;
}