mocra-cluster 0.4.1

Embedded Raft + redb control plane for the mocra distributed crawler framework: leader election, distributed locks with fencing, membership, partition ownership.
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

//! Stub network for single-node deployments.
//!
//! Implements `RaftNetwork` / `RaftNetworkFactory` to satisfy the type requirements of
//! [`Raft::new`](openraft::Raft::new). A cluster with a single voter never issues node-to-node
//! RPCs, so these methods are never called; multi-node RPC (HTTP / gRPC) is a follow-up item
//! (plan A: a small voting core + many workers).

use openraft::error::{InstallSnapshotError, NetworkError, RPCError, RaftError};
use openraft::network::{RPCOption, RaftNetwork, RaftNetworkFactory};
use openraft::raft::{
    AppendEntriesRequest, AppendEntriesResponse, InstallSnapshotRequest, InstallSnapshotResponse,
    VoteRequest, VoteResponse,
};

use crate::raft::{Node, NodeId, TypeConfig};

/// Stub network factory.
#[derive(Clone, Default)]
pub struct StubNetwork;

/// Stub connection.
pub struct StubConnection;

fn stub_err() -> std::io::Error {
    std::io::Error::other(
        "stub network: multi-node RPC not implemented (single-node control plane)",
    )
}

impl RaftNetworkFactory<TypeConfig> for StubNetwork {
    type Network = StubConnection;

    async fn new_client(&mut self, _target: NodeId, _node: &Node) -> Self::Network {
        StubConnection
    }
}

impl RaftNetwork<TypeConfig> for StubConnection {
    async fn append_entries(
        &mut self,
        _req: AppendEntriesRequest<TypeConfig>,
        _option: RPCOption,
    ) -> Result<AppendEntriesResponse<NodeId>, RPCError<NodeId, Node, RaftError<NodeId>>> {
        Err(RPCError::Network(NetworkError::new(&stub_err())))
    }

    async fn install_snapshot(
        &mut self,
        _req: InstallSnapshotRequest<TypeConfig>,
        _option: RPCOption,
    ) -> Result<
        InstallSnapshotResponse<NodeId>,
        RPCError<NodeId, Node, RaftError<NodeId, InstallSnapshotError>>,
    > {
        Err(RPCError::Network(NetworkError::new(&stub_err())))
    }

    async fn vote(
        &mut self,
        _req: VoteRequest<NodeId>,
        _option: RPCOption,
    ) -> Result<VoteResponse<NodeId>, RPCError<NodeId, Node, RaftError<NodeId>>> {
        Err(RPCError::Network(NetworkError::new(&stub_err())))
    }
}