Struct Node 

pub struct Node<T>
where
    T: TypeConfig,
{
    pub node_config: Arc<RaftNodeConfig>,
    /* private fields */
}

Raft node container

Fields

node_config: Arc<RaftNodeConfig>

Raft node config

Implementations

impl<T> Node<T>

where T: TypeConfig,

pub async fn run(&self) -> Result<()>

Starts and runs the Raft node’s main execution loop.

Workflow

1. Establishes network connections with cluster peers
2. Performs cluster health check
3. Marks node as ready for operation
4. Joins the Raft cluster
5. Executes the core Raft event processing loop

Errors

Returns Err if any of these operations fail:

• Peer connection establishment
• Cluster health check
• Raft core initialization
• Event processing failures

Example

let node = Node::new(...);
tokio::spawn(async move {
    node.run().await.expect("Node execution failed");
});

pub fn set_ready(&self, is_ready: bool)

Controls the node’s operational readiness state.

Parameters

• is_ready: When true, marks node as ready to participate in cluster. When false, marks node as temporarily unavailable.

Usage

Typically used during cluster bootstrap or maintenance operations. The readiness state is atomically updated using SeqCst ordering.

pub fn server_is_ready(&self) -> bool

Checks if the node is in a ready state to participate in cluster operations.

Returns

true if the node is operational and ready to handle Raft protocol operations, false otherwise.

Trait Implementations

impl<T> ClusterManagementService for Node<T>

where T: TypeConfig,

fn update_cluster_conf<'life0, 'async_trait>( &'life0 self, request: Request<ClusterConfChangeRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ClusterConfUpdateResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handles cluster membership changes (joint consensus)

Raft Protocol Logic

• Implements cluster configuration changes (Section 6)
• Validates new configuration against current cluster state
• Ensures safety during membership transitions

fn get_cluster_metadata<'life0, 'async_trait>( &'life0 self, request: Request<MetadataRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ClusterMembership>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns current cluster membership and state metadata

Usage

• Administrative API for cluster inspection
• Provides snapshot of current configuration

fn join_cluster<'life0, 'async_trait>( &'life0 self, request: Request<JoinRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<JoinResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Request to join the cluster as a new learner node

fn discover_leader<'life0, 'async_trait>( &'life0 self, request: Request<LeaderDiscoveryRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<LeaderDiscoveryResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

New RPC for leader discovery

impl<T> Debug for Node<T>

where T: TypeConfig,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> RaftClientService for Node<T>

where T: TypeConfig,

fn handle_client_write<'life0, 'async_trait>( &'life0 self, request: Request<ClientWriteRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ClientResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Processes client write requests requiring consensus

Raft Protocol Logic

• Entry point for client proposals (Section 7)
• Validates requests before appending to leader’s log
• Ensures linearizable writes through log replication

fn handle_client_read<'life0, 'async_trait>( &'life0 self, request: Request<ClientReadRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ClientResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handles client read requests with linearizability guarantees

Raft Protocol Logic

• Implements lease-based leader reads (Section 6.4)
• Verifies leadership before serving reads
• Ensures read-after-write consistency

impl<T> RaftElectionService for Node<T>

where T: TypeConfig,

fn request_vote<'life0, 'async_trait>( &'life0 self, request: Request<VoteRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<VoteResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handles RequestVote RPC calls from candidate nodes during leader elections

Raft Protocol Logic

• Part of leader election mechanism (Section 5.2)
• Validates candidate’s term and log completeness
• Grants vote if candidate’s log is at least as up-to-date as local log

impl<T> RaftReplicationService for Node<T>

where T: TypeConfig,

fn append_entries<'life0, 'async_trait>( &'life0 self, request: Request<AppendEntriesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<AppendEntriesResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Processes AppendEntries RPC calls from cluster leader

Raft Protocol Logic

• Heartbeat mechanism (Section 5.2)
• Log replication entry point (Section 5.3)
• Term comparison logic:
  • If incoming term > current term: revert to follower state
  • Reset election timeout on valid leader communication

impl<T> SnapshotService for Node<T>

where T: TypeConfig,

type StreamSnapshotStream = Streaming<SnapshotChunk>

Server streaming response type for the StreamSnapshot method.

fn stream_snapshot<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<SnapshotAck>>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::StreamSnapshotStream>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Learner-driven snapshot streaming

fn install_snapshot<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<SnapshotChunk>>, ) -> Pin<Box<dyn Future<Output = Result<Response<SnapshotResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Leader-driven snapshot streaming

fn purge_log<'life0, 'async_trait>( &'life0 self, request: Request<PurgeLogRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<PurgeLogResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Log compaction request