sorock 0.12.0

A Multi-Raft implementation in Rust
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

use super::*;

pub struct Effect {
    pub state_machine: StateMachine,
    pub voter: Voter,
}

impl Effect {
    /// Advance kernel process once.
    pub async fn exec(self) -> Result<()> {
        let cur_kern_index = self.state_machine.kernel_pointer.load(Ordering::SeqCst);
        ensure!(cur_kern_index < self.state_machine.commit_pointer.load(Ordering::SeqCst));

        let process_index = cur_kern_index + 1;
        let e = self.state_machine.get_entry(process_index).await?;
        let command = Command::deserialize(&e.command);

        let do_process = match command {
            Command::Barrier { .. } => true,
            Command::ClusterConfiguration { .. } => true,
            _ => false,
        };

        if do_process {
            debug!("process kern@{process_index}");
            match command {
                Command::Barrier(term) => {
                    self.voter.commit_safe_term(term);
                }
                Command::ClusterConfiguration { .. } => {}
                _ => {}
            }
            if let Some(kern_completion) = self
                .state_machine
                .kernel_completions
                .lock()
                .remove(&process_index)
            {
                kern_completion.complete();
            }
        }

        self.state_machine
            .kernel_pointer
            .fetch_max(process_index, Ordering::SeqCst);

        Ok(())
    }
}