noxu-log 5.0.0

Log-structured storage engine for Noxu DB
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

//! Replication context.
//!
//!
//! Provides context about high-level operations so the logging level can
//! determine which replication-related actions are required for a given
//! log entry.

use noxu_util::vlsn::Vlsn;

/// Replication context.
///
/// Indicates whether a log entry is part of the replication stream and
/// provides the VLSN (Version Log Sequence Number) context for replication.
///
/// # Variants
///
/// - `NoReplicate`: This operation will not be replicated (read-only, local,
///   or entry type never replicated)
/// - `Master`: This operation is on a replication master and should generate
///   a new VLSN
/// - `Client`: This operation is on a replica applying a replicated entry
///   with the given VLSN
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub enum ReplicationContext {
    /// Not replicated.
    #[default]
    NoReplicate,
    /// Replicated master operation (will generate VLSN).
    Master,
    /// Replicated client operation (applying entry with given VLSN).
    Client {
        /// The VLSN from the replication message.
        vlsn: Vlsn,
    },
}

impl ReplicationContext {
    /// Creates a context for a non-replicated operation.
    pub const fn no_replicate() -> Self {
        ReplicationContext::NoReplicate
    }

    /// Creates a context for a master operation.
    pub const fn master() -> Self {
        ReplicationContext::Master
    }

    /// Creates a context for a client operation with the given VLSN.
    pub fn client(vlsn: Vlsn) -> Self {
        ReplicationContext::Client { vlsn }
    }

    /// Returns true if this operation is in the replication stream.
    pub fn in_replication_stream(&self) -> bool {
        matches!(
            self,
            ReplicationContext::Master | ReplicationContext::Client { .. }
        )
    }

    /// Returns true if this node should generate a VLSN for this operation.
    pub fn must_generate_vlsn(&self) -> bool {
        matches!(self, ReplicationContext::Master)
    }

    /// Returns the client VLSN if this is a client operation.
    pub fn client_vlsn(&self) -> Option<Vlsn> {
        match self {
            ReplicationContext::Client { vlsn } => Some(*vlsn),
            _ => None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_no_replicate() {
        let ctx = ReplicationContext::no_replicate();
        assert!(!ctx.in_replication_stream());
        assert!(!ctx.must_generate_vlsn());
        assert_eq!(ctx.client_vlsn(), None);
    }

    #[test]
    fn test_master() {
        let ctx = ReplicationContext::master();
        assert!(ctx.in_replication_stream());
        assert!(ctx.must_generate_vlsn());
        assert_eq!(ctx.client_vlsn(), None);
    }

    #[test]
    fn test_client() {
        let vlsn = Vlsn::new(42);
        let ctx = ReplicationContext::client(vlsn);
        assert!(ctx.in_replication_stream());
        assert!(!ctx.must_generate_vlsn());
        assert_eq!(ctx.client_vlsn(), Some(vlsn));
    }

    #[test]
    fn test_default() {
        let ctx = ReplicationContext::default();
        assert_eq!(ctx, ReplicationContext::NoReplicate);
    }
}